java 部分语法-阿南达文事网

java 部分语法

包

包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护

相同包下的类可以直接访问，不同包下的类必须导包,才可以使用！导包格式：import 包名.类名;

假如一个类中需要用到不同类，而这个两个类的名称是一样的，那么默认只能导入一个类，另一个类要带包名访问

权限修饰符

权限修饰符：是用来控制一个成员能够被访问的范围。

可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制。

权限修饰符：有四种作用范围由小到大（private -> default -> protected - > public ）

//Father.java
package modefer;public class Father {private void privateMethod(){       //只能本类访问System.out.println("private");      }protected void protectedMethod(){       //本类，同包中的其他类，其他包的子类中System.out.println("protected");}public  void publicMethod(){System.out.println("public");}public static void main(String[] args) {Father f = new Father();f.privateMethod();f.protectedMethod();f.publicMethod();}
}
--------------------
//Son.java
package modefer.itcast;import modefer.Father;public class Son  extends Father {public static void main(String[] args) {Son s= new Son();s.publicMethod();s.protectedMethod();}
}

成员变量一般私有。

方法一般公开。

如果该成员只希望本类访问，使用private修饰。

如果该成员只希望本类，同一个包下的其他类和子类访问，使用protected修饰。

final

修饰类：表明该类是最终类，不能被继承。

修饰方法：表明该方法是最终方法，不能被重写。

修饰变量：表示该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次),几乎不用。

package d3_finall;public class Test {public static void main(String[] args) {}
}final class Son{public void eat(){System.out.println("eat");}
}
// class Sonn extends Son{}     //报错，final修饰类，类不能被继承class Animal{public final void die(){System.out.println("都会死");}
}class Dog extends Animal{       //final修饰方法，方法不能被重写//public void die(){      //报错die()' cannot override 'die()' in 'd3_finall.Animal'; overridden method is final//  System.out.println("doge");//}
}

常量

命名规范：英文单词全部大写，多个单词下划线连接起来。

public class constant {public static final String USER_NAME = "张三";public static final String PASS_WORD = "123456";public static final String ADDRESS = "北京";
}

枚举

枚举类都是继承了枚举类型：java.lang.Enum

枚举都是最终类，不可以被继承。

构造器都是私有的，枚举对外不能创建对象。

枚举类的第一行默认都是罗列枚举对象的名称的。

枚举类相当于是多例模式。

package d4_enum;public enum Season {//第一行都是罗列枚举类实例的名称SPRING,SUMMER,AUTUMN,WINTER;
}

抽象类

抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承。

当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成。此时这个类就可以声明成抽象类。

抽象方法只有方法签名，不能声明方法体。

一个类中如果定义了抽象方法，这个类必须声明成抽象类，否则报错。

抽象类中可以没有抽象方法，但是有抽象方法的必须是抽象类

父类的抽象方法，必须在子类中实现，否则这个类也必须定义成抽象类

抽象类不能创建对象，只能被继承

public abstract class Animal {        //abstract 声明public abstract void run();     //不能写方法体代码
}

模板方法模式

使用场景：当系统中出现同一个功能多处在开发，而该功能中大部分代码是一样的，只有其中部分可能不同的时候

实现步骤

定义一个抽象类。

定义两个个方法，一个是模板方法：把相同代码放里面去，不同代码定义成抽象方法

子类继承抽象类，重写抽象方法。模板方法可以加final关键字，因为模板一般不需要重写

接口

声明一个接口interface

接口实现implements

一个类实现接口，必须重写全部接口的全部抽象方法，否则这个类需要定义成抽象类

public interface 接口名{//常量//抽象方法
}

package d8_interface;//声明一个接口，体现一种规范，规范一定是公开的
public interface Test{//JDK8以前的接口中只能有抽象方法和常量//常量//由于接口体现的是规范化思想，规范化默认都是公开的，所以代码层面public static final可以省略不写String ADDRESS = "北京";public static final String ADD = "北京";//2.抽象方法//由于接口体现的是规范化思想，规范化默认都是公开的，所以代码层面public abstract可以省略不写void run();public abstract void go();
}

类和类的关系：单继承

类和接口的关系：多实现

接口和接口的关系：多继承，一个接口可以同时继承多个接口

多继承整合多个接口为同一个接口，便于子类的实现

面向对象三大特征之三：多态

同类型的对象，执行同一个行为，会表现除不同的行为特征

多态的常见形式

父类类型 对象名称 = new 子类构造器
接口 对象名称 = new 实现类构造器

多态中成员访问特点

方法调用：编译看左边，运行看右边

变量调用：编译看左边，运行也看左边

//test.java
package d10_duotai;public class Test {public static void main(String[] args) {Animal a = new Doge();Animal b = new wugu();a.run();                //狗跑的快，编译看左边，运行看右边System.out.println(a.name);         //打印的是父类的名字编译看左边，运行也看左边b.run();                //乌龟跑的很慢，编译看左边，运行看右边System.out.println(b.name);         //打印的是父类的名字编译看左边，运行也看左边}
}
----------------------------
//Animal.java
package d10_duotai;public abstract class Animal {public abstract void run();public String name ="名字";
}
----------------------------
//Doge.java
package d10_duotai;public class Doge extends Animal{@Overridepublic void run(){System.out.println("狗跑的快");}public String name ="doge狗";
}
----------------------------
//wugu.java
package d10_duotai;public class wugu extends Animal{@Overridepublic void run(){System.out.println("乌龟跑的很慢");}public String name = "乌龟";
}

自动类型转换：子类对象赋值给父类类型的变量指向

强制类型转换：从父到子

此时必须进行强制类型转换：子类对象变量 = （子类）父类类型的变量

作用：可以解决在多态下实现子类特有的功能

instanceof：判断关键字左边的变量指向对象的真实类型，是否是右边的类型或者是其子类型

多态小案列

//Test.java
package d1_duotai_demo;public class Test {public static void main(String[] args) {//创建电脑对象Computer c= new Computer("外星人");c.start();//创建鼠标和键盘对象USB u = new KeyBoard("键盘");c.installUSB(u);USB u1 = new Mouse("鼠标");c.installUSB(u1);c.close();}
}
------------------
//Computer.java
package d1_duotai_demo;public class Computer {private  String name;public void start(){System.out.println("电脑开机了");}public void close(){System.out.println("电脑关机了");}//使用多态，提供USB设备的入口public void installUSB(USB usb){//多态usb.connect();//特有功能先判断再强转if(usb instanceof  KeyBoard){KeyBoard k = (KeyBoard) usb;k.keyDown();}else if(usb instanceof Mouse){Mouse m = (Mouse) usb;m.click();}usb.unconnect();}public Computer(){}public Computer(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}
------------------------------
//KeyBoard.java
package d1_duotai_demo;public class KeyBoard implements  USB{private String name;public KeyBoard(){}public KeyBoard(String name) {this.name = name;}//特有功能public void keyDown(){System.out.println(name+"被敲击了");}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic void connect() {System.out.println("键盘连接成功");}@Overridepublic void unconnect() {System.out.println("键盘弹出成功");}
}
----------------------------
//Mouse.java
package d1_duotai_demo;public class Mouse implements USB{public String name;public Mouse(){}public Mouse(String name) {this.name = name;}//特有方法public void click(){System.out.println(name+"被点击了");}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic void connect() {System.out.println("鼠标连接成功");}@Overridepublic void unconnect() {System.out.println("鼠标弹出成功");}
}
---------------------
//USB.java
package d1_duotai_demo;public interface USB {//接入，拔出共功能void connect();void unconnect();
}