目的
学习代码块的原理，明白怎么使用它和理解它的加载顺序，简单了解；辨析内部类和外部类，学习内部类的基础知识，掌握内部类的使用方法和作用，剖析其具体体现；进入Java三特性之一——继承，学习其基础特征，加深对继承特性的理解
代码块
在程序编程中，可以直接使用“{}”定义一段语句。根据定义的位置以及声明关键字的不同，可以分为四种：普通代码块、构造代码块、静态代码块和同步代码块。一般来说代码块是不能单独运行的，它必须要有运行主体。其形式大致为：
修饰符 {
预先执行的内容，即预处理
}
在对象创建之前，代码块就会被优先调用
实例
class Person{
int age;
//普通代码块
{
age = 30;
System.out.println("代码块 age="+age);
}
//静态代码块
static {
//age = 20;静态代码块里面不能调用成员变量和实例方法
System.out.println("静态代码块");
}
public Person(){
System.out.println("无参构造方法 age="+age);
}
public Person(int age){
this.age = age;
System.out.println("有参构造方法");
}
}
内部类
概念
向对象程序设计中，可以在一个类的内部定义另一个类，这种类称为嵌套（nestedclasses）,它有两种类型，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。
定义一个类，可以在多个地方定义
- 单独创建一个文件管理一个类
- 直接在文件里面，类A的上面和下面创建
- 直接在某个类A内部创建一个类
实例
class RelativeLayout{
String view;
//在显示一个视图前 必须告诉系统这个视图的具体位置
public void show(LayoutParams layout){
System.out.println("视图:"+view+"显示出来了");
System.out.println("left:"+layout.leftMergin+
"top:"+layout.topMergin+
"right:"+layout.rightMergin+
"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 testLayout{
public static void main(String[] args){
//创建一个相对布局 容器视图
RelativeLayout rl = new RelativeLayout();
rl.view = "分享按钮";
//显示这个视图
//准备好这个视图的布局属性
//1.
// RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(20,20,
// 20,20);
// rl.show(params);
//使用匿名对象 只需要使用一次
rl.show(new RelativeLayout.LayoutParams(20,20,
20,20));
}
}
运行结果
1.png
继承
概念
继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以先定义一个类叫车，车有以下属性：车体大小，颜色，方向盘，轮胎，而又由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。
关键 获得父类的方法和属性，并需要添加自己的属性和方法；Java里面只能单继承，以及变相多继承
需要关注点
1.所有类都是直接或间接继承于Object类
2.当调用子类的一个方法时，如果没有就会到父类里面去查找
3.如果子类里面需要调用父类的方法，或者显示调用父类的属性的时候，使用super
@Override
public void walk() {
super.walk();
}
4.如果一个方法需要完成一个功能，又不能单独完成，必须要父类做相应工作，就需要调用super的对应方法
父类做完之后，子类再操作
2.png
子类做点事情之后，调用父类去完成
3.png
- 如果子类里面需要重新实现父类的方法，就需要使用@Override重写
@Override
public void walk() {
System.out.println("学生走路");
}
- 如果父类有自定义构造方法,子类的构造方法里必须显示调用父类的构造方法
- 如果父类有内部类,子类中有同名的内部类,那么父类中的内部类就被屏蔽了;如果非要使用父类中的内部类,只能使用全类名
实例
父类
class Person1{
protected String name;
protected int age;
public Person1(String name,int age){
this.name = name;
this.age = age;
}
public void walk(){
System.out.println(name+"走路");
}
public void eat(){
System.out.println(name+"吃饭");
}
}
子类
class Student extends Person1{
int id;
String school;
public Student(String name, int age, int id, String school){
super(name, age);
this.id = id;
this.school = school;
}
public void study(){
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{" +
"id=" + id +
" name='" + name + '\'' +
", age=" + age +
", school='" + school + '\'' +
'}';
}
}
运用
class TestExtends{
public static void main(String[] args){
//Student xw = new Student();
//xw.name = "Jack";
//xw.age = 20;
//xw.id = 001;
//xw.school = "西南大学";
Student xw = new Student("Jack",20,001,"西南大学");
xw.walk();
System.out.println(xw);
}
}
多态
多态是同一种方法，有多种实现的能力；相同于一个方法在不同的子类中有不同的实现
多态的存在有三个前提：
1.要有继承关系
2.子类要重写父类的方法
3.父类引用指向子类对
实例
class A{
public void info(){
System.out.println("in A");
}
}
class B extends A{
@Override
public void info(){
System.out.println("in B");
}
}
class C extends A{
@Override
public void info(){
System.out.println("in C");
}
}
运用
4.png
注意 如果两个类有继承关系，子类的对象可以使用父类的变量接受（类型的自动向上转换）
demo
5.png
public class Person2 {
protected String name;
protected int age;
public Person2(String name, int age){
this.name = name;
this.age = age;
}
public void walk(){
}
public void eat(){
}
}
class CivilServant extends Person2{
private int salary;
private int count;
public CivilServant(String name, int age,
int salary, int count){
super(name, age);
this.salary = salary;
this.count = count;
}
@Override
public void walk() {
System.out.println("慢慢地走");
}
@Override
public void eat() {
System.out.println("大吃大喝");
}
public void cShow() {
System.out.println("CivilServant{" +
"name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
", count=" + count +
'}');
}
}
class Worker extends Person2{
private int salary;
private String tec;
public Worker(String name, int age, int salary,
String tec){
super(name, age);
this.salary = salary;
this.tec = tec;
}
@Override
public void walk() {
System.out.println("快跑呢");
}
@Override
public void eat() {
System.out.println("急匆匆吃");
}
public void wShow() {
System.out.println( "Worker{" +
"name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
", tec='" + tec + '\'' +
'}');
}
}
class Test3{
public static void main(String[] args){
// Person[] peoples = new Person[6];
ArrayList<Person2> peoples = new ArrayList<>();
Person2 c1 = new CivilServant("小王", 30, 5000, 30);
Person2 c2 = new CivilServant("小李", 32, 7000, 34);
Person2 c3 = new CivilServant("张三", 33, 2000, 32);
//peoples.add((Person2)c1);
peoples.add(c1);
peoples.add(c2);
peoples.add(c3);
Person2 w1 = new Worker("Jack",23,8922, "Android开发");
Person2 w2 = new Worker("Rose",22,10323, "iOS开发");
Person2 w3 = new Worker("Merry",20,8123, "web开发");
peoples.add(w1);
peoples.add(w2);
peoples.add(w3);
for (Person2 p: peoples){
//找到p到底是哪个类型的对象
if(p instanceof CivilServant){
//公务员
CivilServant c = (CivilServant)p;
c.cShow();
c.walk();
c.eat();
}else{
//员工
Worker w = (Worker)p;
w.wShow();
w.walk();
w.eat();
}
}
}
}
心得体会
今天学习了子类、父类，明白了继承是怎么一回事，为以后减少了不少事；但是还是对内部类不太明白，还需要消化
