权限修饰符
public 公共的
protected 受保护的
默认不写 默认的
private 私有的
特征修饰符
final 最终的 不可更改的
static 静态的
abstract 抽象的
native 本地的
transient 瞬时的 短暂的------>序列化
synchronized 同步的 线程问题
volatile 不稳定的
public 公共的 本类 同包 子类 当前项目中任意类的位置只要有对象都可以访问
protected 保护的 本类 同包 子类(通过子类对象在子类范围内部访问)
默认不写 默认的 本类 同包
private 私有的 本类
可以修饰类及类成员(除了块)
修饰类的时候只允许两个 public ， 默认不写
新建一个包packa
packa中定义一个类TestA：
package packa;public class TestA {public static void main(String[] args){TestA ta = new TestA();ta.testPublic();ta.testProtected();ta.testDefault();ta.testPrivate();}//四个修饰符在本类中都可以访问public void testPublic(){System.out.println("我是TestA类中的public修饰符方法");}protected void testProtected(){System.out.println("我是TestA类中的protected修饰符方法");}void testDefault(){System.out.println("我是TestA类中的默认不写修饰符方法");}private void testPrivate(){System.out.println("我是TestA类中的private修饰符方法");}}
四个修饰赋在本类中都可以访问。
同一个包中，再定义一个新的类TestAA：
package packa;
//把TestA中的主方法，放在TestAA中，测试四个修饰符的访问权限。
public class TestAA {public static void main(String[] args){TestA ta = new TestA();ta.testPublic();ta.testProtected();ta.testDefault();//ta.testPrivate();//报错，这是私有的，只能在本类中被访问}
}
私有的修饰符，只能在本类中被访问。其他三个在同包中都可以访问。
在packa中再建立一个包，inner
inner中在建立一个新的类，TestInnerA：
package packa.innera;import packa.TestA;public class TestInnerA {public static void main(String[] args){TestA ta = new TestA();ta.testPublic();//ta.testProtected(); //不好用，报错//ta.testDefault();//不好用，报错//ta.testPrivate();//不好用，报错，私有的}//说明和packa不是同包。
}
TestA和TestInnerA不是同一个包。package 后面的名字不一样，就不是一个包。
新建一个包，packb，这个包和packa并列。
packb中建立一个TestB：
package packb;
import packa.TestA;public class TestB extends TestA{ //TestB是TestA的子类，所以在这个子类范围内可以访问TestA的成员public void testB(){stPublic();//子类可以访问父类的共有方法stProtected();//子类可以访问父类的保护方法}public static void main(String[] args){TestB tb = new TestB();tb.testPublic();//可以调用。子类可以访问父类的共有方法tb.testProtected();//通过继承，可以调用。子类可以访问父类的保护方法TestA ta = new TestA();ta.testPublic();// ta.testProtected();//报错！继承的子类TestB可以访问保护成员，自己却不能访问保护成员。//因为保护成员，只能在本类，同包和子类（通过子类对象在子类范围内部访问）中访问，你这个不是子类对象，也不是本类，不是同包。}
}
//但是一旦出了TestB这个子类的范围，就会报错。比如，你将主方法放在子类的外面，类似下面注释那样，就会报错。
但是一旦出了TestB这个子类的范围，就会报错。比如，你将主方法放在子类的外面，类似下面注释那样，就会报错。
package test;import packb.TestB;public class TestMain {public static void main(String[] args){TestB tb = new TestB();tb.testPublic();//tb.testProtected();//报错，因为不在子类的范围内了。}
}
保护成员只能在本类，同包和子类（通过子类对象在子类范围内部访问）中访问。本类和同包比较容易理解，主要这个子类，重点一：是子类的对象。重点二：是子类范围内部。
私有成员的好处，控制你的输入，不会让你随便修改属性的值，而且可以通过方法判断你给的值，是否合适。例子如下：
package person;public class Person {//属性public String name;private int age;public String sex;//方法//设计一个方法 用来取得age属性的值// 提供条件?不需要 返回值? 获取的age的值public int getAge(){//ifreturn this.age;}//设计一个方法 用来给age属性赋值// 提供条件? age的值 返回值?voidpublic void setAge(int age){if(age<0){System.out.println("对不起 您还没出生呢 请给正确的年龄范围");this.age = -1000;//抛出异常}else if(age>130){System.out.println("对不起 您已经升仙啦 请给正确的年龄范围");this.age = -1000;//抛出异常}else {this.age = age;}}
}
主方法：
package person;public class Test {public static void main(String[] args){//创建类的过程是在Java中描述的过程//1.创建对象Person p = new Person();//2.对象的引用 . 调用属性p.name = "郑中拓";p.setAge(18); //如果设置的值不合理，会提醒你的。你也不能随意设置不合理的值了。p.sex = "男";System.out.println("今年"&#Age());
//以前可以通过p.age直接访问属性了，
//但是由于我们把属性设置成了私有的，所以需要方法进行访问了。}
}
Java类和类之间的关系
继承 关联 依赖
Java面向对象的四个特征
继承 封装 多态 (抽象)
封装 : 将一些数据或执行过程 进行一个包装
目的 : 保护这些数据 或 执行过程的安全
1.可以修饰什么
2.修饰以后有什么特点
package test_final;public class TestFinal {public static void main(String[] args){final int a = 1;//声明变量 内存开辟栈内存空间//上面那一句也可以写成下面的两行/* final int a ;a = 1;*///如果在定义变量时没有赋初始值//给变量一次存值的机会(因为变量在栈内存空间内 没有默认值 如果不给机会 就没法用啦)a = 10;//报错//一旦变量被存储了一个值 若用final修饰后 则不让再次改变 ----> 相当于常量啦(值没法动)}
}
package test_final;public class TestFinal {final int[] x;x = new int[]{1,2,3};x[0] = 10;x[0] = 100;//不报错！因为我们改的是栈内存里的值，而不是改了x的地址// x = new int[5];//这就会报错。因为试图修改引用的地址，肯定报错。}
}
private final String name = "";空值都行，但是必须给初值。package test_final;public class Animal {public void eat(){System.out.println("动物的吃饭方法");}
}
子类：
package test_final;public class Person extends Animal{//extends-->扩展public void eat(){System.out.println("子类重写(覆盖)父类的吃饭方法");}
}
主方法：
package test_final;public class TestFinal {public static void main(String[] args){Person p = new Person();p.eat();}
}
//这是测试重写，完全没有问题。
但是一旦我将父类的方法，利用final修饰，子类就不可以重写了。
package test_final;public class Animal {public final void eat(){System.out.println("动物的吃饭方法");}
}
子类重写eat时会报错的。
package test_final;public class Person extends Animal{//报错！不可以重写。public void eat(){System.out.println("子类重写(覆盖)父类的吃饭方法");}
}
1.可以修饰什么
2.修饰后有什么特点
1.可以修饰 ：
不用static的代码：
public class Person {public String name; //暂时用public讲，方便。实际最好设置为私有的。public int age;//斜体public static void main(String[] args){Person p1 = new Person();p1.name = "阿拓小哥哥";p1.age = 18;Person p2 = new Person();// p2 =p1;//如果加上这句话，两个输出都是：姬成小姐姐了。p2.name = "姬成小姐姐";p2.age = 16;//第二个对象使用的age就是第一个对象的ageSystem.out.println(p1.name+"今年"+p1.age+"岁");System.out.println(p2.name+"今年"+p2.age+"岁");}
}
//输出结果：
//阿拓小哥哥今年18岁
//姬成小姐姐今年16岁
// p2 =p1;//如果加上这句话，两个输出都是：姬成小姐姐今年16岁
加上static以后：
//age加上了static特征修饰符
public class Person {public String name; //暂时用public讲，方便。实际最好设置为私有的。public static int age;//斜体public void test(){System.out.println("我是普通方法"+Person.age); //非静态方法可以访问静态成员}public static void testStatic(){System.out.println("我是静态方法");} //静态方法可以访问静态成员 //但是不可以访问非静态成员,因为一个静态方法，对应着好多的对象，不知道访问哪一个对象的成员了。public static void main(String[] args){Person p1 = new Person();p1.name = "阿拓小哥哥";p1.age = 18;Person p2 = new Person();p2.name = "姬成小姐姐";p2.age = 16;//第二个对象使用的age就是第一个对象的ageSystem.out.println(p1.name+"今年"+p1.age+"岁");System.out.println(p2.name+"今年"+p2.age+"岁");}
}
//结果：
//阿拓小哥哥今年16岁 ???为什么是16岁呢？？
//姬成小姐姐今年16岁
//原因只可能是：第二个对象使用的age就是第一个对象的age
那么static修饰的存在哪了呢？？实际上存在了静态元素区。
age存在了静态元素区。
package bookstroe;/**书店类*/
public class BookStore {private static final int BOOKSTROE_ADMIN = 0;private static final int BOOKSTROE_VIP = 1;private static final int BOOKSTROE_NORMAL = 2;
//为什么加static？是因为用了static，就不用创建对象，通过类名字就可以直接访问了，BookStore.BOOKSTROE_ADMIN
//为什么加final？为了让这个变量值不再改变了。public void buyBook(float price,int identity){switch(identity){case BookStore.BOOKSTROE_ADMIN:System.out.println("尊敬的书店管理员，您购买的图书应付款:"+price*0.5);break;case BookStore.BOOKSTROE_VIP:System.out.println("尊敬的书店VIP客户，您购买的图书应付款:"+price*0.8);break;case BookStore.BOOKSTROE_NORMAL:System.out.println("尊敬的普通用户，您购买的图书应付款:"+price);break;default:System.out.println("对不起，系统查不到您的身份，不许买书");}}
}
package bookstroe;import java.util.Scanner;public class TestMain {public static void main(String[] args){BookStore bookStore = new BookStore();Scanner input = new Scanner(System.in);System.out.println("请输入图书金额");float price = Float();System.out.println("请出示您的身份");int identity = Int();bookStore.buyBook(price,identity);}
}命名规约
类名首字母大写
属性 方法 变量首字母小写 第二个大写
构造方法 与类名一致 首字母大写
包 全部字母小写 注意区分关键字
静态常量 全部字母大写 _
私有属性对应的方法 getName/setName
见名知义
设计模式 23种 (内功心法)
设计模式不是知识点；
设计模式是一种设计经验的总结；
设计模式用来解决某些场景下的某一类问题的---->通用的解决方案；
有了设计模式之后 可以让代码更容易被理解 确保了复用性 可靠性 可扩展性。
设计模式分为三类
设计–>一个类只能创建一个对象，有效减少内存占用空间
设计一个系统—>百度 搜索引擎
public class Baidu{public void 搜索(String keyword){}}
创建一个Baidu对象 new
调用搜索的方法 ， 做事情 ， 方法执行一遍
问题：
同一时间有很多很多很多很多人在使用这个系统
解决方法：
对象—>只创建一个 ， 堆内存中就只开辟一个空间
调用一次方法—>临时执行一次 方法执行空间就回收啦
父类：
package test;public class Animal {public String test = "AnimalField";public static String testStatic = "AnimalStaticField";public Animal(){System.out.println("我是animal中默认无参数的构造方法");}{st(); //块中调用了普通方法System.out.println("我是animal中的普通代码块"+test);}static{stStatic();System.out.println("我是animal中的静态代码块"+testStatic);}public void test(){System.out.println("我是animal类中的普通方法");}public static void testStatic(){System.out.println("我是animal类中的静态方法");}
}子类：
package test;public class Person extends Animal{public String test = "personField";public static String testStatic = "personStaticField";public Person(){//super();//默认调用父类无参数的构造方法System.out.println("我是person中默认无参数的构造方法");}{stPerson(); //调用了普通方法System.out.println("我是person中的普通代码块"+test);}static{stStatic();System.out.println("我是person中的静态代码块"+testStatic);}public void testPerson(){System.out.println("我是person类中的普通方法");}public static void testStatic(){System.out.println("我是person类中的静态方法");}
}主方法：
package test;public class Test {public static void main(String[] args){//加载类的过程---静态元素已经加载new Person();//p.hashCode();//1.加载父类//2.父类会产生自己的静态空间 属性 方法 块// 执行静态块//3.加载子类//4.子类会产生自己的静态空间 属性 方法 块// 执行静态块//--------------------------------------------------//5.开辟对象空间//6.加载父类的非静态成员 属性 方法 块 构造方法//7. 执行块 执行父类构造方法//8.加载子类的非静态成员 属性 方法 块 构造方法//9. 执行块 执行子类构造方法//10.将对象空间的地址引用交给 变量来存储 Person p = new Person();}
}先加载父类Animal模板，加载父类模板同时就加载了Animal静态元素空间。
然后加载子类Person，顺道直接加载了子类Person类的静态元素空间。
静态元素空间存放的是静态的属性，方法和块。
运行new Person()的过程：
加载类的过程-----静态元素已经加载
先1.加载父类
2.父类会产生自己的静态空间 静态的属性 方法 块 执行块
执行静态块
3.加载子类
4.子类会产生自己的静态空间 静态的属性 方法 块 执行块
执行静态块
然后执行new Person()，
5.开辟对象空间
6.加载父类的非静态成员 属性 方法 块 构造方法
7.执行块 执行父类构造方法
8.加载子类的非静态成员 属性 方法 块 构造方法
9.执行块 执行子类构造方法
10.将对象空间的地址引用交给 变量来存储
