JavaSE-进阶

课程第1天

( 1 )分类思想

分类思想概述：分工协作,专人干专事

( 2 )分包思想

**分包思想概述：**如果将所有的类文件都放在同一个包下,不利于管理和后期维护,所以,对于不同功能的类文件,可以放在不同的包下进行管理

包的概述：

• 包

  本质上就是文件夹

• 创建包

  多级包之间使用 " . " 进行分割
  多级包的定义规范：公司的网站地址翻转(去掉www)
  比如：黑马程序员的网站址为www.itheima.com
  后期我们所定义的包的结构就是：com.itheima.其他的包名

• 包的命名规则

  字母都是小写

  包的注意事项

  package语句必须是程序的第一条可执行的代码

  package语句在一个java文件中只能有一个

  如果没有package,默认表示无包名

( 3 )static关键字

​ static关键字的特点

• 被类的所有对象共享

  是我们判断是否使用静态关键字的条件

• 随着类的加载而加载，优先于对象存在

  对象需要类被加载后，才能创建

• 可以通过类名调用

  也可以通过对象名调用

  static关键字的注意事项：

  • 静态方法只能访问静态的成员
  • 非静态方法可以访问静态的成员，也可以访问非静态的成员
  • 静态方法中是没有this关键字

课程第2天

( 1 )继承的使用

继承的格式：

• 继承通过extends实现

• 格式：class 子类 extends 父类 { }

• 举例：class Dog extends Animal { }

• 示例代码

  public class Fu {public void show() {System.out.println("show方法被调用");}
  }
  public class Zi extends Fu {public void method() {System.out.println("method方法被调用");}
  }
  public class Demo {public static void main(String[] args) {//创建对象，调用方法Fu f = new Fu();f.show();Zi z = new Zi();z.method();z.show();}
  }

  继承好处:

  • 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
  • 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

  继承弊端:

  • 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

  Java中继承的特点

  1. Java中类只支持单继承，不支持多继承

     • 错误范例：class A extends B, C { }

  2. Java中类支持多层继承

  3. 多层继承示例代码：

     public class Granddad {public void drink() {System.out.println("爷爷爱喝酒");}}public class Father extends Granddad {public void smoke() {System.out.println("爸爸爱抽烟");}}public class Mother {public void dance() {System.out.println("妈妈爱跳舞");}}
     public class Son extends Father {// 此时，Son类中就同时拥有drink方法以及smoke方法
     }
     

• 继承好处

  • 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
  • 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

  继承弊端

  • 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

( 2 )、四种权限修饰符

( 3 )、抽象类

抽象类以及抽象方法的格式

抽象类和抽象方法必须使用 abstract 关键字修饰

//抽象类的定义
public abstract class 类名 {}//抽象方法的定义
public abstract void eat();

• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

• 抽象类不能实例化

• 抽象类可以有构造方法

• 抽象类的子类

  ​ 要么重写抽象类中的所有抽象方法

  ​ 要么是抽象类

  模板设计模式

• 设计模式

  设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
  使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

• 模板设计模式

  把抽象类整体就可以看做成一个模板，模板中不能决定的东西定义成抽象方法
  让使用模板的类（继承抽象类的类）去重写抽象方法实现需求

• 模板设计模式的优势

  模板已经定义了通用结构，使用者只需要关心自己需要实现的功能即可

• 示例代码

  模板类

  /*作文模板类*/
  public abstract class CompositionTemplate {public final void write(){System.out.println("<<我的爸爸>>");body();System.out.println("啊~ 这就是我的爸爸");}public abstract void body();
  }
  

  实现类A

  public class Tom extends CompositionTemplate {@Overridepublic void body() {System.out.println("那是一个秋天, 风儿那么缠绵,记忆中, " +"那天爸爸骑车接我放学回家,我的脚卡在了自行车链当中, 爸爸蹬不动,他就站起来蹬...");}
  }
  

  实现类B

  public class Tony extends CompositionTemplate {@Overridepublic void body() {}/*public void write(){}*/
  }
  

  测试类

  public class Test {public static void main(String[] args) {Tom t = new Tom();t.write();}
  }
  

( 4 )、final关键字

• fianl关键字的作用

  • final代表最终的意思，可以修饰成员方法，成员变量，类

• final修饰类、方法、变量的效果

  • fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）

  • final修饰方法：该方法不能被重写

  • final修饰变量：表明该变量是一个常量，不能再次赋值

    • 变量是基本类型,不能改变的是值

    • 变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的

    • 举例

      public static void main(String[] args){final Student s = new Student(23);s = new Student(24);  // 错误s.setAge(24);  // 正确
      }
      

( 5 )、代码块

代码块分类 ,以及各自的特点

局部代码块

• 位置: 方法中定义

• 作用: 限定变量的生命周期，及早释放，提高内存利用率

• 示例代码

  public class Test {/*局部代码块位置：方法中定义作用：限定变量的生命周期，及早释放，提高内存利用率*/public static void main(String[] args) {{int a = 10;System.out.println(a);}// System.out.println(a);}
  }
  

  构造代码块

  • 位置: 类中方法外定义

  • 特点: 每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行

  • 作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性

  • 示例代码

    public class Test {/*构造代码块:位置：类中方法外定义特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性*/public static void main(String[] args) {Student stu1 = new Student();Student stu2 = new Student(10);}
    }class Student {{System.out.println("好好学习");}public Student(){System.out.println("空参数构造方法");}public Student(int a){System.out.println("带参数构造方法...........");}
    }
    

    静态代码块

    • 位置: 类中方法外定义

    • 特点: 需要通过static关键字修饰，随着类的加载而加载，并且只执行一次

    • 作用: 在类加载的时候做一些数据初始化的操作

    • 示例代码

      public class Test {/*静态代码块:位置：类中方法外定义特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次作用：在类加载的时候做一些数据初始化的操作*/public static void main(String[] args) {Person p1 = new Person();Person p2 = new Person(10);}
      }class Person {static {System.out.println("我是静态代码块, 我执行了");}public Person(){System.out.println("我是Person类的空参数构造方法");}public Person(int a){System.out.println("我是Person类的带...........参数构造方法");}
      }
      

课程第3天

( 1 )、接口

接口的概述

• 接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
• Java中接口存在的两个意义
  1. 用来定义规范
  2. 用来做功能的拓展

接口的特点

• 接口用关键字interface修饰

  public interface 接口名 {} 
  

• 类实现接口用implements表示

  public class 类名 implements 接口名 {}
  

• 接口不能实例化

  ​ 我们可以创建接口的实现类对象使用

• 接口的子类

  ​ 要么重写接口中的所有抽象方法

  ​ 要么子类也是抽象类

  接口的成员特点

• 成员特点

  • 成员变量

    ​ 只能是常量
    ​ 默认修饰符：public static final

  • 构造方法

    ​ 没有，因为接口主要是扩展功能的，而没有具体存在

  • 成员方法

    ​ 只能是抽象方法

    ​ 默认修饰符：public abstract

    ​ 关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

• 代码演示

  • 接口

    public interface Inter {public static final int NUM = 10;public abstract void show();
    }
    

  • 实现类

    class InterImpl implements Inter{public void method(){// NUM = 20;System.out.println(NUM);}public void show(){}
    }
    

  • 测试类

    public class TestInterface {/*成员变量: 只能是常量 系统会默认加入三个关键字public static final构造方法: 没有成员方法: 只能是抽象方法, 系统会默认加入两个关键字public abstract*/public static void main(String[] args) {System.out.println(Inter.NUM);}}
    

( 2 )、多态

多态的前提

• 要有继承或实现关系

• 要有方法的重写

• 要有父类引用指向子类对象

• 代码演示

  class Animal {public void eat(){System.out.println("动物吃饭");}
  }class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");}
  }public class Test1Polymorphic {/*多态的前提:1. 要有(继承 \ 实现)关系2. 要有方法重写3. 要有父类引用, 指向子类对象*/public static void main(String[] args) {// 当前事物, 是一只猫Cat c = new Cat();// 当前事物, 是一只动物Animal a = new Cat();a.eat();}
  }
  

多态的好处和弊端

• 好处

  ​ 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

• 弊端

  ​ 不能使用子类的特有成员

( 3 )、内部类

内部类概念

• 在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

内部类定义格式

• 格式&举例

  /*格式：class 外部类名{修饰符 class 内部类名{}}
  */class Outer {public class Inner {}
  }
  

内部类的访问特点

• 内部类可以直接访问外部类的成员，包括私有

• 外部类要访问内部类的成员，必须创建对象

• 示例代码：

  /*内部类访问特点：内部类可以直接访问外部类的成员，包括私有外部类要访问内部类的成员，必须创建对象*/
  public class Outer {private int num = 10;public class Inner {public void show() {System.out.println(num);}}public void method() {Inner i = new Inner();i.show();}
  }
  

• 成员内部类的定义位置

  • 在类中方法，跟成员变量是一个位置

• 外界创建成员内部类格式

  • 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
  • 举例：Outer.Inner oi = new Outer().new Inner();

• 私有成员内部类

  • 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

  • 示例代码：

    class Outer {private int num = 10;private class Inner {public void show() {System.out.println(num);}}public void method() {Inner i = new Inner();i.show();}
    }
    public class InnerDemo {public static void main(String[] args) {//Outer.Inner oi = new Outer().new Inner();//oi.show();Outer o = new Outer();o.method();}
    }
    

静态成员内部类

• 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

• 静态成员内部类中的静态方法：外部类名.内部类名.方法名();

• 示例代码

  class Outer {static class Inner {public void show(){System.out.println("inner..show");}public static void method(){System.out.println("inner..method");}}
  }public class Test3Innerclass {/*静态成员内部类演示*/public static void main(String[] args) {// 外部类名.内部类名 对象名 = new 外部类名.内部类名();Outer.Inner oi = new Outer.Inner();oi.show();Outer.Inner.method();}
  }
  

• 局部内部类定义位置

  • 局部内部类是在方法中定义的类

• 局部内部类方式方式

  • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
  • 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

• 示例代码

  class Outer {private int num = 10;public void method() {int num2 = 20;class Inner {public void show() {System.out.println(num);System.out.println(num2);}}Inner i = new Inner();i.show();}
  }
  public class OuterDemo {public static void main(String[] args) {Outer o = new Outer();o.method();}
  }
  

• 匿名内部类的前提

  • 存在一个类或者接口，这里的类可以是具体类也可以是抽象类

• 匿名内部类的格式

  • 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }

  • 举例：

    new Inter(){@Overridepublic void method(){}
    } 
    

• 匿名内部类的本质

  • 本质：是一个继承了该类或者实现了该接口的子类匿名对象

• 匿名内部类的细节

  • 匿名内部类可以通过多态的形式接受

    Inter i = new Inter(){@Overridepublic void method(){}
    }
    

• 匿名内部类直接调用方法

  interface Inter{void method();
  }class Test{public static void main(String[] args){new Inter(){@Overridepublic void method(){System.out.println("我是匿名内部类");}}.method();	// 直接调用方法}
  }
  

( 4 )、Lambda表达式

Lambda表达式的标准格式

• 格式：

  ​ (形式参数) -> {代码块}

  • 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
  • ->：由英文中画线和大于符号组成，固定写法。代表指向动作
  • 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

• 组成Lambda表达式的三要素：

  • 形式参数，箭头，代码块

Lambda表达式的省略模式

• 省略的规则

  • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
  • 如果参数有且仅有一个，那么小括号可以省略
  • 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

• 代码演示

  public interface Addable {int add(int x, int y);
  }public interface Flyable {void fly(String s);
  }public class LambdaDemo {public static void main(String[] args) {
  //        useAddable((int x,int y) -> {
  //            return x + y;
  //        });//参数的类型可以省略useAddable((x, y) -> {return x + y;});//        useFlyable((String s) -> {
  //            System.out.println(s);
  //        });//如果参数有且仅有一个，那么小括号可以省略
  //        useFlyable(s -> {
  //            System.out.println(s);
  //        });//如果代码块的语句只有一条，可以省略大括号和分号useFlyable(s -> System.out.println(s));//如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉useAddable((x, y) -> x + y);}private static void useFlyable(Flyable f) {f.fly("风和日丽，晴空万里");}private static void useAddable(Addable a) {int sum = a.add(10, 20);System.out.println(sum);}
  }
  

Lambda表达式的使用前提

• 使用Lambda必须要有接口
• 并且要求接口中有且仅有一个抽象方法

课程第4天

( 1 )、Math类

• 1、Math类概述

  • Math 包含执行基本数字运算的方法

• 2、Math中方法的调用方式

  • Math类中无构造方法，但内部的方法都是静态的，则可以通过 类名.进行调用

• 3、Math类的常用方法

( 2 )、System类

System类的常用方法

示例代码

• 需求：在控制台输出1-10000，计算这段代码执行了多少毫秒

  public class SystemDemo {public static void main(String[] args) {// 获取开始的时间节点long start = System.currentTimeMillis();for (int i = 1; i <= 10000; i++) {System.out.println(i);}// 获取代码运行结束后的时间节点long end = System.currentTimeMillis();System.out.println("共耗时：" + (end - start) + "毫秒");}
  }
  

( 3 )、Object类toString ， equals方法的常见方法作用(包含面试题)

• Object类概述

  • Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份

• 查看方法源码的方式

  • 选中方法，按下Ctrl + B

• 重写toString方法的方式

  • 1. Alt + Insert 选择toString
  • 1. 在类的空白区域，右键 -> Generate -> 选择toString

• toString方法的作用：

  • 以良好的格式，更方便的展示对象中的属性值

• 示例代码：

  class Student extends Object {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
  }
  public class ObjectDemo {public static void main(String[] args) {Student s = new Student();s.setName("林青霞");s.setAge(30);System.out.println(s); System.out.println(s.toString()); }
  }
  

  • equals方法的作用

    • 用于对象之间的比较，返回true和false的结果
    • 举例：s1.equals(s2); s1和s2是两个对象

  • 重写equals方法的场景

    • 不希望比较对象的地址值，想要结合对象属性进行比较的时候。

  • 重写equals方法的方式

    • 1. alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
    • 1. 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上。

  • 示例代码：

    class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！