文章目录
代码块概述
代码块是类的5大成分之一（成员变量，构造器，方法，代码块，内部类），定义在类中方法外。
在JAVA类下，使用{}括起来的代码被称为代码块
静态代码块
格式：static{}
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次
使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。
import java.util.ArrayList;
public class staticcode {
/**
* 静态代码块，static修饰，属于类，与类一起有限加载一次自动触发执行
* 可用于初始化静态资源
*/
public static String s;
public static ArrayList<Integer> list=new ArrayList<>();
static {
System.out.println("=====静态代码块被触发======");
s="someday";
list.add(1);
list.add(3);
}
public static void main(String[] args) {
System.out.println("=====main执行======");
System.out.println(s);
System.out.println(list);
}
}
//输出结果
//=====静态代码块被触发======
//=====main执行======
//someday
//[1, 3]
实例代码块（了解，用的少）
格式：{}
特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行。
使用场景：初始化实例资源
public class staticcode2 {
private String name;
public staticcode2(){
System.out.println("无参构造器被执行");
}
/**
* 实例代码块，无static修饰，属于对象。每次构建对象时，都会触发一次执行
*/
{
name="tony";
System.out.println("实例代码块被执行");
}
public static void main(String[] args) {
staticcode2 s1=new staticcode2();
System.out.println(s1.name);
staticcode2 s2=new staticcode2();
System.out.println(s2.name);
}
}
设计模式
开发中经常遇到一些问题，一个问题通常有n种解法，但其中肯定有一种解法时最优的，这个最优的解法被人总结出来称为设计模式。
设计模型有20多种，对应20多种软件开发中会遇到的问题。
学习设计模式主要是学2点：
1.这种模式用来解决什么问题。
2，遇到这种问题，该模型是怎么写的，他是如何解决这个问题。
单例模式
保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
饿汉单例设计模式
在用类获取对象的时候，对象已经提前为你创建好了
设计步骤：
定义一个类，把构造器私有。
定义一个静态变量存储一个对象。
/**
* 使用饿汉单例实现单例类
*/
public class SingleInstance {
/**
* 饿汉单例是在获取对象前，对象已经提前准备好了一个。
* 这个对象只能是一个，所以定义静态成员变量。
*/
public static SingleInstance instance=new SingleInstance();
/**
* 必须把构造器私有化
*/
private SingleInstance(){
}
}
public class singletest {
public static void main(String[] args) {
SingleInstance s1= SingleInstance.instance;
SingleInstance s2= SingleInstance.instance;
System.out.println(s1==s2);
}
}
懒汉单例设计模式
在真正需要该对象的时候，才去创建一个对象（延迟加载对象）
设计步骤：
定义一个类，把构造器私有。
定义一个静态变量存储一个对象。
创建一个返回单例对象的方法。
public class SingleInstance1 {
private SingleInstance1(){
}
private static SingleInstance1 instance1;
public static SingleInstance1 getInstance(){
if (instance1==null){
//为null的时候，为第一次创建
instance1=new SingleInstance1();
}
return instance1;
}
}
public class singletest1 {
public static void main(String[] args) {
SingleInstance1 s1=SingleInstance1.getInstance();
SingleInstance1 s2=SingleInstance1.getInstance();
System.out.println(s1==s2);
}
}
面向对象三大特征之二：继承
Java中提供的关键词extends，用这个关键字，可以让一个类和另一个类建立起父子关系。
提高代码复用性，减少代码冗余，增强类的功能扩展型，
public class Student extends People{
}
Student称为子类（派生类），People称为父类（基类或超类）。
Java中子类更强大。
作用：当子类继承父类后，就可以直接使用父类公共的属性和方法了。
public class People {
/**
* 父类
*/
public void run(){
System.out.println("renhuipao");
}
}
public class Student extends People{
/**
* 子类
*/
}
public class test {
public static void main(String[] args) {
Student s=new Student();
s.run();
}
}
Demo
public class People {
/**
* 父类
*/
private String name;
private int age;
public void queryCourse(){
System.out.println(name+"在查看课表~~");
}
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;
}
}
public class Student extends People{
/**
* 子类
*/
public void writerInfo(){
System.out.println(this.getName()+"写下了");
}
}
public class test {
public static void main(String[] args) {
Student s=new Student();
s.setName("tom");
s.setAge(18);
s.queryCourse();
s.writerInfo();
}
}
继承的特点：
1.子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
2.Java是单继承模型：一个类只能继承一个直接父类。
3.Java不支持多继承、但是支持多层继承。
比如A不能同时继承B和C，但A可以继承B，同时B可以继承C。
4.Java中所有的类都是Object类的子类。
在子类方法中访问成员（成员变量、成员方法）满足：就近原则
先子类局部范围查找
然后子类成员范围查找
然后父类成员范围查找，如果父类还没有找到则报错。
如果子父类中出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类怎么办？
可以通过super关键字，指定访问父类成员
public class Demo {
public static void main(String[] args) {
dog d=new dog();
d.showname();
}
}
class Animal{
public String name="动物";
}
class dog extends Animal{
public static String name="狗";
public void showname(){
String name="哈士奇";
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
//输出结果
哈士奇
狗
动物
方法重写
在继承体系中，子类出现了和父类中一摸一样的方法声明，我们就称子类这个方法是重写的方法
应用场景
当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。
子类可以重写父类中的方法。
public class test {
public static void main(String[] args) {
newphone p=new newphone();
p.call();
p.message();
}
}
/**
* 旧手机
*/
class oldphone{
public void call(){
System.out.println("call");
}
public void message(){
System.out.println("message");
}
}
class newphone extends oldphone{
@Override //添加override后，1.如果重写错误，编译会出错，比如将call写成call1会报错。 2.代码可读性高
public void call(){
super.call();
System.out.println("facetime");
}
@Override
public void message(){
super.message();
System.out.println("picture");
}
}
子类继承父类后构造器的特点
子类中所有的构造器默认都会先访问父类中无参构造器，再执行自己。
原因：
子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。
Demo
调用父类有参构造器
public class People {
/**
* 父类
*/
private String name;
private int age;
public People(){
}
public People(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;
}
}
public class Student extends People {
/**
* 子类
*/
public Student(){
}
public Student(String name,int age){
super(name,age);
}
}
public class test {
public static void main(String[] args) {
Student s=new Student("ds",33);
System.out.println(s.getName());
System.out.println(s.getAge());
}
}
