标签：之间 静态代码块 values 类加载 btn 不同的 自动 lan 没有
public class ClassDemo1 {
System.out.println("Hello,World");
}
//报错原因，其不是类中的成分！，必须是五大成分。
作用：初始化类的对象并返回引用
格式：
修饰符 类名 (形参) {}
构造器初始化对象：
类名 对象名称 = new 构造器;
注意：一个类默认自带一个无参构造器，若手动写一个，自带无参构造器就会被覆盖
使用static修饰的成员（方法和成员变量）属于类本身的，否则便是属于对象的
按照有无static修饰，成员变量和方法可以分为：
成员变量
静态成员变量(有static)：也叫类变量，属于类本身，直接使用类名访问即可
静态成员变量有static修饰，属于类本身，与类加载一次，因为只有一份所以可以被类和类的对象共享访问
实例成员变量(无static)：属于类的每个对象，必须使用对象访问
属于对象，必须先创建对象，然后用对象去访问
成员方法
package cn.imut._02成员变量;
public class Student {
public static String schoolName = "IMUT";
private String name;
public static void main(String[] args) {
//Student可以不写
System.out.println(Student.schoolName);
Student student = new Student();
student.name = "实例变量";
System.out.println(student.name);
}
}
注意：不建议使用对象访问静态成员变量（静态成员方法），虽然可以访问。应该使用类访问
继承是Java中一个特殊的关系，是一种子类到父类的关系。
被继承的类称为：父类/超类、继承父类的类称为：子类
继承后成员变量的访问特点
继承后成员方法的访问特点
子类继承了父类，子类变得到了父类的某个方法，但是子类若觉得父类的方法不好用，可以进行重写，从而覆盖父类的方法
注意！静态方法和私有方法不可以被重写
引用类型作为一种类型，可以在一切使用类型的地方使用！
父类知道子类一定会完成某个功能，但是每个子类完成的情况是不同的。
子类会使用自己重写的功能，那么父类的该功能就可以定义成抽象方法，子类重写调用子类自己即可
类似于一个牌子，告诉子类一定会做重写这个功能！
子类一旦做了，重写父类的方法，父类的方法便没有任何用处，因此定义为抽象方法，且有抽象方法的类一定是一个抽象类
public class AbstractDemo {
public static void main(String[] args) {
Dog dog = new Dog();
dog.run();
}
}
class Dog extends Animal {
@Override
public void run() {
System.out.println("狗跑的快");
}
}
class Cat extends Animal {
@Override
public void run() {
System.out.println("猫跑的快");
}
}
abstract class Animal {
//抽象方法没有方法体
public abstract void run();
}
注意：一个类继承了抽象类，就必须重写完全部的抽象方法，否则这个类必须定义成抽象类
注意：抽象类除了不能创建对象，类的其他成分都具备！比如构造器，也是拥有的
注意：抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
接口是比抽象类更加抽象的抽象，接口中全都是抽象方法（JDK8之前），接口同样不能创建对象
接口体现的是规范思想，实现接口的子类必须重写完接口的全部抽象方法
核心关键字 interface
接口与类是多实现关系，一个类同时可以实现多个接口
接口与接口是多继承关系，一个接口可以同时继承多个接口
JDK1.8 之后，接口新增了三个方法
静态代码块：属于类，会与类一起加载，而且自动触发一次！
public class CodeDemo {
//在main上先加载
static {
System.out.println("静态代码块~");
}
public static void main(String[] args) {
System.out.println("main方法~");
}
}
实例代码块：属于类的每个对象，随着对象一起加载。每次创建对象都触发执行一次
final是”最终“的意思，可以修饰类、方法、变量
注意：abstract 和 final 是互斥的关系！
类的对象只有有限个、确定的。我们称此类为枚举类
当需要定义一组常量时，强烈建议使用枚举类
如果枚举类中只有一个对象，则可以作为单例模式的实现方式
JDK1.5 之前需要自定义枚举类
package cn.imut.test;
//自定义枚举类
public class Season {
//1.声明Season的属性
private final String seasonName; //名称
private final String seasonDesc; //描述
//2.私有化类的构造器，并给对象属性赋值
private Season(String seasonName, String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//3.提供当前枚举类的多个对象
public static final Season SPRING = new Season("春天","春暖花开");
public static final Season SUMMER = new Season("夏天","夏日炎炎");
public static final Season AUTUMN = new Season("秋天","秋高气爽");
public static final Season WINTER = new Season("冬天","冰天雪地");
//4.其他述求1：获取枚举类对象的属性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
//4.其他述求2：提供toString()
@Override
public String toString() {
return "Season{" +
"seasonName=‘" + seasonName + ‘\‘‘ +
", seasonDesc=‘" + seasonDesc + ‘\‘‘ +
‘}‘;
}
}
测试
package cn.imut.test;
public class SeasonTest {
public static void main(String[] args) {
Season summer = Season.SUMMER;
System.out.println(summer);
}
}
JDK1.5 新增的 enum关键字用于定义枚举类
package cn.imut.test;
//使用enum关键字定义枚举类
//说明：定义的枚举类默认继承于java.lang.Enum类
public enum Season1 {
//1.提供当前枚举类的对象，多个对象之间用逗号隔开，末尾对象分号结束
SPRING("春天","春暖花开"),
SUMMER("夏天","夏日炎炎"),
AUTUMN("秋天","秋高气爽"),
WINTER("冬天","冰天雪地");
//2.声明Season的属性
private final String seasonName; //名称
private final String seasonDesc; //描述
//3.私有化类的构造器，并给对象属性赋值
private Season1(String seasonName, String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.其他述求1：获取枚举类对象的属性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
}
若枚举类只有一个对象，则可以作为一种单例模式的实现方式
常用
情况一、实现接口，在enum类中实现抽象方法
情况二
public enum Season1 implements Info{
//1.提供当前枚举类的对象，多个对象之间用逗号隔开，末尾对象分号结束
SPRING("春天","春暖花开") {
public void show() {
System.out.println("春天在哪里");
}
},
SUMMER("夏天","夏日炎炎") {
public void show() {
System.out.println("夏天在哪里");
}
},
AUTUMN("秋天","秋高气爽") {
public void show() {
System.out.println("秋天在哪里");
}
},
WINTER("冬天","冰天雪地") {
public void show() {
System.out.println("冬天在哪里");
}
};
总结
同一个类型的对象，执行同一个行为，在不同的状态下会表现出不同的行为特征
识别技巧
多头的使用前提
必须存在继承或者实现关系
必须存在父类类型的变量引用子类类型的对象
需要存在方法重写
优劣势
父类类型的变量或者对象必须强制类型转换成子类类型的变量，否则报错。
Java建议
使用 instanceof 判断前面的变量是否是后面的类型或者其子类类型才会返回 true
Interface USB
public interface USB {
void connect(); //插入
void unConnect(); //拔出
}
class Mouse
//鼠标
public class Mouse implements USB {
private String name;
public Mouse(String name) {
this.name = name;
}
public void dbClick() {
System.out.println(name + "双击666");
}
@Override
public void connect() {
System.out.println(name + "成功插入");
}
@Override
public void unConnect() {
System.out.println(name + "成功拔出");
}
}
class KeyBoard
public class KeyBoard implements USB {
private String name;
public KeyBoard(String name) {
this.name = name;
}
public void keyDown() {
System.out.println(name + "敲出键盘侠");
}
@Override
public void connect() {
System.out.println(name + "成功插入");
}
@Override
public void unConnect() {
System.out.println(name + "成功拔出");
}
}
class Computer
public class Computer {
public void installUSB(USB usb) {
//usb有可能是一切
usb.connect();
if(usb instanceof Mouse) {
((Mouse) usb).dbClick();
}else if(usb instanceof KeyBoard) {
((KeyBoard) usb).keyDown();
}
usb.unConnect();
}
}
class Test
public class Test {
public static void main(String[] args) {
Computer computer = new Computer();
USB lj = new Mouse("罗技");
computer.installUSB(lj);
USB hhkb = new KeyBoard("HHKB");
computer.installUSB(hhkb);
}
}
定义在一个类内部的类就是内部类
作用：可以提供更好的封装性，有更多的权限修饰符，有更多的控制
分类
匿名内部类：一个没有名字的局部内部类，可以简化代码
特点
package cn.imut._08匿名内部类;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Anonymity {
public static void main(String[] args) {
//创建窗口
JFrame win = new JFrame("登录功能");
//设置窗口大小
win.setSize(400,300);
//居中
win.setLocationRelativeTo(null);
//加按钮
JButton btn = new JButton("登录");
JPanel panel = new JPanel();
panel.add(btn);
win.add(panel);
//监听器
btn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("用户点击触发了登录");
}
});
//显示
win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
win.setVisible(true);
}
}
包：管理各种不同的技术
相同的包下，类可以直接访问，不同的包下必须先导包。
权限修饰符：
(private --> 缺省 --> protected --> public)
四种修饰符的访问权限范围：
| private | 缺省 | protected | public | |
|---|---|---|---|---|
| 本类中 | √ | √ | √ | √ |
| 本包下其他类中 | × | √ | √ | √ |
| 其他包下的类中 | × | × | × | √ |
| 其他包下的子类中 | × | × | √ | √ |
标签：之间 静态代码块 values 类加载 btn 不同的 自动 lan 没有
原文地址：https://www.cnblogs.com/yfyyy/p/12584359.html
