Java学习——第三章 第四章

第三章 面向对象编程

3.1面向对象与面向过程

1.面向对象，面向过程

2.Java类与类的成员

（1）属性：对应类中的成员变量

（2）行为：对应类中的成员方法

3.2类与对象

1.类的语法格式

修饰符class类名{

​ 属性声明；

​ 方法说明；

}

说明：修饰符public：类可以被任意访问

​ 类正文要用{}括起来

例如：

public class Person{
    public int age;            //声明共有变量age
    
    public void showAge{       //声明方法showAge()
    System.out.println(age);
    }
    public int getAge(){      //如果方法有返回值，那么方法最后一行一定是返回相应数据，使用return
        return age;
    }
}

3.3属性

1.关于属性

2.变量的分类：成员变量与局部变量

二者的区别

3.4方法

1.关于方法

2.例子

//编写教师类和学生类，并通过测试类创建对象进行测试

//学生类
public class Student {

   /**
    * 属性
    */
	
	public String name;//姓名
	public int age;//年龄
	public String course;//参与的课程
	public String interest;//兴趣
	
	
	/**
	 * 方法
	 */
	
	public void showInfo() {
	//输出学生个人信息
    System.out.println("姓名 ：" + name);
    System.out.println("年龄 ：" + age);
    System.out.println("课程 ：" + course);
    System.out.println("兴趣 ：" + interest);
    
	}
}

//教师类
public class Teacher {
	/**
	 * 属性
	 */
	public String name;//姓名
	public String major;//专业
	public String course;//教的课
	public int teachingAge;//教龄
	
	/**
	 * 方法
	 */
	public void showInfo() {
		//输出教师个人信息
		System.out.println("姓名：" + name);
		System.out.println("专业：" + major);
		System.out.println("教的课：" + course);
		System.out.println("教龄：" + teachingAge);

	}

}

//Text类
public class Text {
	
	public static void main (String[] args) {
		
		
		//创建学生对象
		
		Student stu = new Student();
		//引用
	    stu.name = "小明";
		stu.age = 15;		
		stu.course = "语文、数学、英语";
		stu.interest = "游泳、跑步";
		stu.showInfo();
		
		
		System.out.println("=================================================");
		
		
		//创建教师对象
		
		Teacher teacher = new Teacher ();
		
		//引用
		
		teacher.name = "老张";
		teacher.major = "计算机";
		teacher.course = "计算机科学技术";
		teacher.teachingAge = 30;
		teacher.showInfo();
    }
}

结果：

姓名 ：小明

年龄 ：15

课程 ：语文、数学、英语

兴趣 ：游泳、跑步

=================================================

姓名：老张

专业：计算机

教的课：计算机科学技术

教龄：30

3.5对象的创建和使用

1.对象的创建

public class Person {
    //成员变量	
	public String name;//姓名
	public int sex;//性别0男1女
	public int age;//年龄
	//展示信息方法
	public void showInfo() {
		System.out.println(name);
		System.out.println(sex);
		System.out.println(age);
	}
}

2.对象的使用

public class Text {
	public static void main(String[] args) {
		//实例化Person对象，也就是创建Person对象
    Person p = new Person();//声明一个Person类型的变量，名为p，实例化Person类并给p赋值    
        //new Person()就是实例化Person类
        p.name = "Lisa";//给p对象的name属性赋值
        p.showName();//对象方法的调用        
	}
}

对于对象的使用有两个地方，操作对象的变量，调用类方法

3.对象的产生

4.匿名对象

​ new Student().showInfo();

3.6再谈方法（method）

1.方法

2.方法的调用

·方法只有被调用才会执行

注意：

1.没有返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写

2.定义方法时，方法的结果应该返回给调用者，交由第哦啊用着处理

3.方法中只能调用方法，不可以再方法内部定义方法

3.方法的重载（overload）

4.体会可变个数的形参

5.方法的参数传递

JVM的内存模型

引用对象

方法的参数传递

1.如果方法的形参时基本数据类型，那么实参向形参传递参数时，就是直接传递值，把实参的值复制给形参。

2.如果方法的形参时对象，那么实参，向形参传递参数时，也就是把值给形参，这个值时实参再栈中的值，也就是引用对象在堆内存中的地址

基本数据类型都是保存在栈内存中，引用对象在栈内存中的值，也就是引用对象的地址，那么方法的参数传递时传递值（时变量在栈内存的当中的值）

6.包package和引用import

包package

import

JDK中主要的包介绍

3.7封装和隐藏

1.封装和隐藏

public class Person {

    //使用public只是把类的属性开发出来，让调用者随意使用
    //需要使用private不让调用者随意使用的属性做封装和隐藏
	private int age;
	
	public int setAge(int i) {			
		age = i ;
		return age;		
	}
    
	public void getAge() {		
		if( age >= 0 && age < 130 ) {
			System.out.println("年龄为：" + age );
		}else System.out.println("输入的年龄为：" + age + "。不在0到130之间。");
		
	}
}

public class PersonText {
	public static void main(String[] args) {
		
		Person p = new Person();
		
        p.setAge(150);
		p.getAge();

	}

}
//输出的结果为    输入的年龄为：150。不在0到130之间。

2.四种访问权限修饰符

3.8构造器（构造方法）

1.构造器特征

（1）具有与类相同的名称

（2）它不声明返回值类型。（与声明为void不同）

（3）它不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

2.构造器的作用

创建对象 给对象进行初始化

Order o = new Order(); Person p = new Person(Peter,15);

如：

public class Person{
    //使用构造器给成员变量初始化数值
    public Person(){
        age = 1;
        name = "张三";
    }
    
    public int age;
    public String name;
    
    public void showInfo(){
        System.out.println("姓名：" + name);
        	System.out.println("年龄" + age);       
    }
}

public class Person{
    //使用构造器给成员变量初始化数值
    //可以直接在调用时赋值
    public Person(int age,String name){
        this.age = age;
        this.name = name;
    }//带参数的构造方法
    
    public int age;
    public String name;
    
    public void showInfo(){
        System.out.println("姓名：" + name);
        	System.out.println("年龄" + age);       
    }
}

3.关于构造器

（1）构造器根据参数不同，可分为两类：

·隐式无参构造器（系统默认提供）

·显式定义一个或多个构造器（无参、有参）

（2）注意点

·Java语言中，每个类都至少又有一个构造器

·默认构造器的修饰符与所属类的修饰符一致

·一旦显式定义了构造器，则系统不再提供默认构造器

·一个类可以创建多个重载的构造器

·弗雷德构造器不可被子类继承

new对象实际上就是调用类的构造方法

4.例题

(1)

//1.在定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18.
//2.修改上题中类和构造器，增加name属性，使得每次创建Person对象的同时初始化对象的age属性值和name属性值。
public class Person{

    public Person(int age, String name){
        age = 18;
        this.age = age;
        this.name = name;
    }
    
    public int age;
    public String name;
    
    public void showInfo(){
        System.out.println("姓名：" + name);
        	System.out.println("年龄" + age);       
    }
}

public class Text {
	
	public static void main (String[] args) {
        Person p = new Person(20,"Lisa")
        System.out.println(p.age);
		System.out.println(p.name);    
    }
}

(2)

//编写两个类，TriAngle和TextTriAngle，其中TriAngle中声明私有的底边长base和高height，同时声明公共方法访问私有变量；另一个类中使用这些公共方法，计算三角形的面积。
public class TriAngle {

    //成员变量
	private int high;
	private int base;
    
    //计算面积
    public double countArea(int x,int y) {
		high = x ;
		base = y ;
		return high * base * 0.5 ;
	}
	//输出面积
	public void showArea() {
		System.out.println("面积为" + high * base * 0.5 );
	}

}

public class TextTriAngle {
	public static void main(String[] args) {
		
		TriAngle t = new TriAngle();
		t.countArea(1,3);
		t.showArea();
	}
}
//输出结果为   面积为1.5

5.构造器重载

public class Person1 {	
    
    //多个构造器。   
    //构造器的重载就是为了方便调用，方便灵活创建出不同需要的对象
	public Person1() {			
	}
	
	public Person1(int age) {	
		this.age = age ;
	}
	
	public Person1(String name) {
		this();  //调用构造器Person1()
		this.name = name ;
	}
	
	//构造方法 初始化成员变量 name age
    public Person1(int age,String name) {
    	
    	this(1); //等同于调用public Person1(int age)
    	
    	this.age = age ; //age为形参，而this。name是成员变量。
    	this.name = name ;
    }
    
	//成员变量  年龄 姓名
	public int age ; 
	public String name;
        	
        }
}

3.9关键字——this

1.什么是this

含义： 1.在方法内部使用，即这个方法所属对象的引用

​ 2.在构造器内部使用，表示该构造器正在初始化的对象

this 表示当前对象，可以调用类的属性、方法和构造器

当在方法内部需要用到该方法的对象时，使用this

2.使用this，调用属性、方法

package 基础02;

public class Person1 {
	
	public Person1() {	
		
	}
	
	public Person1(int age) {	
		this.age = age ;
	}
	
	public Person1(String name) {
		this();  //调用构造器Person1()
		this.name = name ;
	}
	
	//构造方法 初始化成员变量 name age
    public Person1(int age,String name) {
    	
    	this(1); //等同于调用public Person1(int age)
    	
    	this.age = age ; //age为形参，而this。name是成员变量。
    	this.name = name ;
    }
    
	//成员变量  年龄 姓名
	public int age ; 
	public String name;
    	
        //设置姓名  
    	public void setName(String name) {
    		this.name = name ;
    	}
    	
    	//设置姓名
    	public void setName1(String name) {
    		this.setName(name);
    	}

    	//展示信息
        public void showInfo() {       	
        	System.out.println("姓名：" + name);
        	System.out.println("年龄" + age);       	
        	
        	//1.当形参与成员变量重名时，如果在方法内部需要哦使用成员变量，必须添加this来表明该成员变量时类成员
        	//2.在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性
        	
        }
}

		public class Text{
         public static void main(String[] args){



        Person1 p1 = new Person1(18, "小明");
		
		p1.setName("小刚");
		
		p1.showInfo();
		
		p1.setName1("小红");
		p1.showInfo();
		
             
   }

注意：1.使用this（） 必须放在构造器首行!

​ 2.使用this调用本类中其他的构造器，保证至少有一个构造器时不用this的。

3.JavaBean

（1）什么是JavaBean

（2）get和set方法

package 基础02;
/**
 * 属性对应的get和set方法
 * 
 * @author 13088
 *
 */
public class Person2 {
	
	private String name;
	private int sex; //男0 女1
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getSex() {
		return sex;
	}
	public void setSex(int sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

public class Text {
	
	public static void main (String[] args) {
		
Person2 p2 = new Person2();
		
		p2.setName("小华");
		p2.setSex(0);
		p2.setAge(18);
		
		System.out.println(p2.getName());
		System.out.println(p2.getSex());
		System.out.println(p2.getAge());
    }
}

（3）快捷设施对应属性的get和set方法

1.设置好属性后右键单击空白选中

2.想生成什么的get和set的方法就在哪个属性前打勾

3.生成完毕

第四章 高级类的特性1

4.1继承

1.关于继承

需要写多个 内容差不多的类 用到继承 extends

2.如何使用

这是Person类，共有的属性在这里

package day7;

public class Person {
	
	public String name;
	public int sex;
	public int age;
	
	public void showInfo() {
		System.out.println(name);
		System.out.println(sex);
		System.out.println(age);
	}

}

Student类里，除了这三个还有一个特别的属性 school

package day7;

public class Student extends Person {
    //用extends关键字来继承Person类中的三个共有属性
		public String school;//特有属性school另外再定义
		
	public void showInfo() {
		System.out.println(this.name);
		System.out.println(this.sex);
		System.out.println(this.age);
		System.out.println(this.school);
	}

}

同理 teacher类也是如此，特殊属性是course

package day7;

public class Teacher extends Person {
	public String course;
	
	public void showInfo() {
		System.out.println(this.name);
		System.out.println(this.sex);
		System.out.println(this.age);
		System.out.println(this.course);
	}

}

其他特殊的子类也是如此

Person类时父类 其他是子类

3.

（1)类继承语法规则

public class Student extends Person {}

（2）作用

继承让类与类之间产生关系，提供了多态的前提

不要紧为了获取其它类中莫一个功能而去继承

（3）关于继承的规则

子类不能直接访问父类中私有的（private）的成员变量和方法，只能通过其他操作（如通过setter或getter）来访问

4.单继承

Java只支持单继承，不能 多重继承。

4.2方法的重写（override）

1.定义

在子类中可以根据需要对从父类中继承来的方法进行改造，方法的重置、覆盖。在程序执行时，子类的方法将覆盖弗雷德方法。

2.要求

3.override重写

4.3四种访问权限修饰符

4.4关键字supper

1.定义与注意点

2.调用父类的构造器

3.this和supper的区别

4.5简单类对象的实例化过程

4.6多态性

1.多态性的定义与使用

（1）方法的重载（overload）和重写（overwrite）

（2）对象的多态性——可以直接应用在抽象类接口上

2.Java引用类变量的两种类型

编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。

若编译时类型和运行时类型不一致，就会出现多态（Polymorphism）

3.对象的多态

（1）在Java中，子类的对象可以替父类的对象使用

一个对象只能有一种确定的数据类型

一个引用类型变量可能只想（引用）多种不同类型的对象

Person p = new Person();

Person e = new Student(); //Person类型的变量e，指向Student类型的对象

（2）子类可看作是特殊的父类，所以父类类型那个的引用的可以指向子类的对象：向上转型（upcasting）

（3）一个引用类型变量如果声明为父类的类型，但实际引用的时子类对象，那么该变量就不能再访问子类中添加的属性和方法

Student m = new Student();

m.school = “puk” //合法，Student类有school成员变量

Person e = new Student();

e.school = “puk” //非法，Person类没有school成员变量

属性是在编译时确认的，编译时e为Person类型，没有school成员变量，因而编译错误。

4.虚拟方法调用（Virtual Method Invocation)

5.instanceof操作符

6.小结

4.7 Object类,包装类（Wrapper）

一、Object类

1.定义

（1）Object类时所有Java类的根父类

（2）如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类

  public class Person{

​           ...

​           }

//等价于：

​      public class Person extrens Object{

​           ...

​           }

//如：

method(Object obj){...}  //可以接收忍耐和类作为其参数

Person o = new Person();

method(o);

2.对象类型转换（Casting）

3.==操作符与equals方法

4.String对象的创建

二、包装类（Wrapper）

1.基本数据类型包装成包装类的实例——装箱

通过包装类的构造器实现：

int i = 500; Integer t = new Integer

还可以通过字符串参数构造包装类对象：

Folat f = new Folat(“4.56”);

Long l = new Long(“asdf”); //NumberFormatException

2.获得包装类对象中包装的基本类型变量——拆箱

调用包装类的***。xxxValue（）***方法：

boolean b = bObj.booleanValue();

JDK1.5之后，支持自动装箱，自动拆箱

3.字符串转化成基本数据类型

通过包装类的构造器实现

int i = new Integer(“12”);

通过包装类的parseXxx(String s)静态方法：

Folat f = Folat.parseFolat(“12.1”);

4.基本数据类型转换成字符串

调用字符串重载的valueOf()方法：

String fstr = String.valueOf(2…34f);

更直接的方式：

String intStr = 5 + ""

三、toString方法

父类Object的toString方法就输出当前对象的内存地址 如果要你想要输出类的其他信息，重写toString