目的：
了解到类的定义除了成员变量和方法外还可以添加代码块，内部类等，还学习了类的三大特性
技术
1.代码块：
在创建一个对象之前需要先做点准备工作
1.构造方法
2.静态变量
3.静态方法 必须主动调用才执行
代码块：在对象创建之前就优先会被调用
修饰符（只可以是static){
预先执行的内容
}
- 静态代码块 里面不能调用成员变量和实例方法 先于所有执行
- 类里面可以有多个代码块
- 执行顺序和出现顺序相同
- 尽量不要在类里面写多个代码块
class Person{
int age;
//代码块
{
age = 30;
System.out.println("代码块+age"+age);
}
//静态代码块
static {
// age = 20;静态代码块不能调用成员变量和实例方法
System.out.println("静态代码块");
}
public Person(){
System.out.println("无参构造方法");
}
public Person(int age){
this.age = age;
System.out.println("有参构造方法");
}
}
2.内部类：
定义一个类 可以在多个地方定义
1.单独创建一个文件管理一个类
2.直接在文件里面 类A的上面和下面创建
3.直接在某个类A内部创建一个类
一个类A依附于另一个类B
静态内部类的定义于使用：（静态内部类不能实现很好的封装性，应该为普通内部类）
class RelativeLayout{
String view;
//在显示一个视图前 必须告诉系统这个视图的具体位置
public void show(LayoutParams layout){
System.out.println("视图："+view+"显示出来了");
System.out.println("left:"+layout.leftMergin+"right:"+layout.rightMergin);
System.out.println("top:"+layout.topMergin+"bottom:"+layout.bottomMergin);
}
//定义一个内部类 用于管理相对布局的具体布局属性
public static class LayoutParams{
float leftMergin;
float topMergin;
float rightMergin;
float bottomMergin;
public LayoutParams(float leftMergin,float topMergin,float rightMergin,float bottomMergin){
this.leftMergin = leftMergin;
this.topMergin = topMergin;
this.rightMergin = rightMergin;
this.bottomMergin = bottomMergin;
}
}
}
class textLayout{
public static void main(String[] agrs){
//创建一个相对布局 容器视图
RelativeLayout rl = new RelativeLayout();
rl.view = "分享按钮";
//显示这个视图
//准备好这个视图的布局属性
//1.
//显示方法1
RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(20,20,20,20);
rl.show(params);
//显示方法2
//匿名使用
rl.show(new RelativeLayout.LayoutParams(20,20,20,20));
}
}
普通静态内部类：
class TextInner{
int a;
int b;
//static int b;内部类任然可以调用，只要成员变量，方法存在就行 static提前存在
Inner inner;
class Inner{
//非静态的内部类 可以访问外部类的属性和方法
public Inner(){
a =20;
b =30;
show();
}
}
public void text() {
inner = new Inner();
}
public void show(){
System.out.println("a+b="+(a+b));
}
}
3.类的三大特性：
（1）.封装：
类来封装属性和方法
访问权限private public protected(只能在同一个包里面可调用)
（2）.继承：
获得父类的方法和属性 并且需要添加自己的属性和方法
关键字：A extends B A继承于B
Java里面只能单继承，但可以变向多继承：A extends B B extends C （则A变向继承C）
所有的类都是直接或间接继承于Object类
父类于子类：
class People{
String name;
int age;
public People(String name,int age){
this.age = age;
this.name = name;
}
public void walk(){
System.out.println(name+"：人走路");
}
public void eat(){
System.out.println(name+"：人吃饭");
}
}
class Student extends People{
int id;
String school;
public Student(String name,int age,int id,String school){
super(name,age);
this.school = school;
this.age = age;
}
public void study(){
System.out.println(name+"：人学习");
}
public void show(){
System.out.println("name:"+name);
}
//方法重写
@Override
public void walk(){
System.out.println("学生优雅地走路");
}
@Override
public void eat(){
System.out.println("学生小口吃饭");
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", school='" + school + '\'' +
", id="+id+'\''+
'}';
}
}
当调用子类的一个方法时，如果没有就会到父类里面去查找
如果在子类里面要调用父类的方法或者显示调用父类的属性使用super
什么情况下需要在一个方法里面调用super的对应方法？
public void walk(){
super.walk();
}
如果一个方法需要完成一个功能，又不能单独完成，必须要父类
做相应的工作，1.父类做完之后 子类再操作
onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
2.子类做点事情之后 在调用父类去完成
protected void onDestroy() {
//...
super.onDestroy();
}
如果子类里面需要重新实现父类的方法 就需要重写
@override
如果父类有构造方法
子类的构造方法里必须显示调用父类的构造方法
如果父类有内部类，子类中有同名的内部类 则父类中的内部类就被屏蔽了
如果非要用父类中的内部类 只能加上全类名
运行于结果：
class TextExtends{
public static void main(String[] agrs){
Student xw = new Student("xw",20,1100,"xinandaxue");
System.out.println(xw);
xw.walk();
}
}
Student{name='xw', age=20, school='xinandaxue', id=0'}
学生优雅地走路
Process finished with exit code 0
（3）.多态：
1.同一个方法 多种实现=在不同类中的不同实现
2.如果有继承关系 子类的对象可以使用父类变量接受
类型的自动向上转换
实际编程：
要求：（对类的多态的学习使用）
定义一个Person类： name age
提供有参数的构造方法
walk方法 eat方法
公务员类： salary 看杂志数量 show方法
公司职员类：salary tec show方法
创建多个公务员和公司职员 放到一个数组里面
将数组里面所有人信息输出
1.类的定义：
class Person1{
String name;
int age;
public Person1(String name,int age){
this.name = name;
this.age = age;
}
public void walk(){
System.out.println("走");
}
public void eat(){
System.out.println("吃");
}
}
class Official extends Person1{
int salary;
int totalPaper;
public Official(String name,int age,int salary,int totalPaper){
super(name,age);
this.salary = salary;
this.totalPaper = totalPaper;
}
@Override
public void walk(){
System.out.println("xiaixa走");
}
@Override
public void eat(){
System.out.println("xiaixa吃");
}
public void oShow(){
System.out.println("name:"+name+" age:"+age+" salary="+salary+" totalPaper="+totalPaper);
}
}
class Staff extends Person1{
int salary;
String tec;
public Staff(String name,int age,int salary,String tec){
super(name,age);
this.salary = salary;
this.tec = tec;
}
@Override
public void walk(){
System.out.println("tang走");
}
@Override
public void eat(){
System.out.println("tang吃");
}
public void sShow(){
System.out.println("name:"+name+" age:"+age+" salary="+salary+" tec="+tec);
}
}
2.创建对象，进行保存和输出信息：
public class work {
public static void main(String[] args){
// Person1[] people = new Person1[10];
ArrayList<Person1> peoples = new ArrayList<>();
Person1 o1= new Official("xiaxia",18,1,10);
Person1 o2= new Official("xionger",1,1,10);
Person1 o3= new Official("xiongda",2,1,10);
// Official o1 = new Official("xiaixa",180,1,10);
// peoples.add((Person1)o1);
peoples.add(o1);
peoples.add(o2);
peoples.add(o3);
Person1 s1 = new Staff("tangtang",19,20,"Javaxuexi");
Person1 s2 = new Staff("Jack",19,20,"Cxuexi");
Person1 s3 = new Staff("Meryy",19,20,"C#xuexi");
peoples.add(s1);
peoples.add(s2);
peoples.add(s3);
for(Person1 p :peoples){
//判断属于那种类型的人
if(p instanceof Official){
//公务员
Official official = (Official)p;
official.oShow();
official.eat();
official.walk();
}else{
//公司职员
Staff staff = (Staff)p;
staff.sShow();
staff.eat();
staff.walk();
}
}
}
}
(1).若oShow() sShow()方法均改为toString方法，则两个子类方法和属性差不多
不需要判断p的类型，直接输出用toString System.out.println(p);即可输出p的相关信息
(2).instanceof
它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。
(3).将公务员类对象于公司职员类对象这两种不同类型的对象放在同一个数组里面，只能申明为公共的父类的类型。
如 Person1 o2= new Official("xionger",1,1,10);
Person1 s1 = new Staff("tangtang",19,20,"Javaxuexi");
心得：
今天又是一个特别充实的一天，没有像昨天那样百般无聊的一直编程，而是讲解了许多知识点，听着感觉很有味道。
