2021-11-03

类和对象

类是一个模板，它描述一类对象的行为和状态。
类–用来描述一组具有相同性质或者特征的复合数据类型，类中可以包含变量和方法。
类中的变量或者方法是什么被使用的？
通过对象来调用类里面的变量和方法来使用
对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：
　声明：声明一个对象，包括对象名称和对象类型。
　实例化：使用关键字 new 来创建一个对象。
　初始化：使用 new 创建对象时，会调用构造方法初始化对象。
1.对象特征
　1.对象是由我们自己定义的类来创建出来的。
　2.对象实际上就是类的具体实现。
　类–抽象【抽取象什么一样的东西】–模板【设计图】
　对象–实现–实例【楼房】
　3.没有类就没有对象
　4.一个类可以创建出多个对象
　5.类是对象的模板，对象是类的真实表现
2.对象的作用？
调用类中的变量和方法
3.如何创建对象？[new]
1.当前类中–new+构造方法—this
2.其他类中–new+构造方法
格式 ： new 构造方法( [参数值] );
例如：

package com.wangxing.zyb;
public class Person {
	public Person(){
		System.out.println("无参构造方法");
	}
	public Person(String name){
		System.out.println("有参构造方法");
	}
	//实例变量
	public String test1;
	//静态变量
	public static String dox1;
}

package com.wangxing.zyb;
public class MainTest {
	public static void main(String args[]) { 
		/*
		Person  per1=new Person();//Person数据类型  per1变量名称  new Person();数据值
		Person  per2=new Person("张三");
		// 1.局部变量在其他类中年不能访问。
	    // 2.实例变量只能对象访问
		per1.test1="张三";
		System.out.println("实例变量=="+per1.test1);
		String str1=per1.test1;
		System.out.println("实例变量=="+str1);
	    // 3.静态变量类名访问，可以对象访问
		Person.dox1="lisi";
		per2.dox1="wangwu";
		System.out.println("静态变量"+Person.dox1);
		System.out.println("静态变量"+per2.dox1);
		String name1=Person.dox1;
		String name2=per2.dox1;
		System.out.println("静态变量"+name1);
		System.out.println("静态变量"+name2);
		// 4.实例变量在同一个类的多个对象之间不能数据共享,静态变量在同一个类的多个对象之间能数据共享
		Person per1=new Person();
		Person per2=new Person();
		per1.test1="张三";
		per2.test1="李四";
		System.out.println("per1.test1=="+per1.test1);
		System.out.println("per2.test1=="+per2.test1);
		per1.test1="zhangsansan";
		per2.test1="lisisi";
		System.out.println("per1.test1=="+per1.test1);
		System.out.println("per2.test1=="+per2.test1);
		*/
		Person per1=new Person();
		Person per2=new Person();
		per1.dox1="zhangsan";
		per2.dox1="lisisi";
		System.out.println("per1.dox1=="+per1.dox1);
		System.out.println("per2.dox2=="+per2.dox1);
	}
}

4.对象访问变量
　1.局部变量在其他类中年不能访问。
　2.实例变量只能对象访问
　3.静态变量类名访问，可以对象访问
　4.实例变量在同一个类的多个对象之间不能数据共享，静态变量在同一个类的多个对象之间能数据共享
例如:

package com.wangxing.zyb2;

public class TestClass {
	//无参数构造方法
	public TestClass() {
		System.out.println("无参数构造方法");
	}
	//有参数的构造方法
	public TestClass(String name) {
		System.out.println("有参数构造方法");
	}
	//实例方法
	public void ShiliMethod() {
		System.out.println("实例方法");
	}
	//有参数的实例方法
	public void ShiliMethod1(int id,String name) {
		System.out.println("实例方法--参数id=="+"id"+";参数name="+name);
	}
	//有返回值，方法体中的最后一句是return,返回的数据值要与方法的返回值类型匹配
	//有返回值的实例方法
	public String ShiliMethod2() {
		System.out.println("有返回值的实例方法");
		return "zhangsan";
	}
	//有参数,有返回值的实例方法
	public String ShiliMethod3(int id,String name) {
		System.out.println("有返回值，有参数的实例方法");
		String info="id="+id+",name="+name;
		return "info";
	}
	//静态方法
	public static void staticMethod() {
		System.out.println("静态方法");
	}
	//有参数的静态方法
	public static void staticMethod1(int id,String name,int age) {
		System.out.println("实例方法--参数id=="+"id"+";参数name="+name+";age="+age);
	}
	//有返回值，方法体中的最后一句是return,返回的数据值要与方法的返回值类型匹配
	//有返回值的静态方法
	public static int staticMethod2() {
		System.out.println("有返回值的静态方法");
		return 1001;
	}
	//有参数,有返回值的静态方法
	public static int staticMethod3(int id,String name,int age) {
		System.out.println("有参数，有返回值的静态方法");
		int num=id+age;
		return num;
	}
}

package com.wangxing.zyb2;
public class Main {
	public static void main(String[] args) {
		//1.构造方法的访问--new
		TestClass tc1=new TestClass();
		//2.实例方法只能对象访问
		tc1.ShiliMethod();
		//3.静态方法类名访问，可以对象访问
		TestClass.staticMethod();
		tc1.ShiliMethod();
		//4.有参数方法，需要传递参数【个数，类型】
	}
}

5.对象访问方法
　1.构造方法的访问–new
　2.实例方法只能对象访问
　3.静态方法类名访问，可以对象访问
　4.有参数方法，需要传递参数【个数，类型】【要什么，给什么】
　5.有返回值，方法体中的最后一句是return,返回的数据值要与方法的返回值类型匹配，
　调用有返回值的方法需要定义变量来接收方法的返回值【给什么，收什么】
例如:

package com.wangxing.zyb2;
public class Main {
	public static void main(String[] args) {
		//1.传值
		TestClass tc2=new TestClass("zhangsan");
		tc2.ShiliMethod1(1001,"lisi");
		TestClass.staticMethod1(1002, "wangwu", 23);
		//2.传变量
		String name1="zhangsansan";
		TestClass tc3=new TestClass(name1);
		int id1=1001;
		String name2="lisisi";
		tc3.ShiliMethod1(id1, name2);
		int id2=1001;
		String name3="wangwuwu";
		int age=25;
		TestClass.staticMethod1(id2, name3, age);
		//调用有返回值的方法需要定义变量来接收方法的返回值
		TestClass tc4=new TestClass();
		String info1=tc4.ShiliMethod2();
		System.out.println("shiliMethod2方法的返回值=="+info1);
		int intvalue=TestClass.staticMethod2();
		System.out.println("staticMethod2方法的返回值=="+intvalue);
		//【要什么，给什么】,【给什么，收什么】
		TestClass tc5=new TestClass();
		String strinfo=tc5.ShiliMethod3(1001, "zhangsan");
		System.out.println("staticMethod3方法的结果=="+strinfo);
		int numinfo=TestClass.staticMethod3(1001, "lisi", 24);
		System.out.println("staticMethod3方法的结果=="+numinfo);	
	}
}

6.对象的内存分配原理

类与类之间有没有关系？
如果有这种关系是什么？
这种关系有什么特征？

继承

1.什么是继承
　基于一个已存在的类，创建一个新的类。已存在的类即父类，新的类即子类，继承就是子类继承并拥有父类的属性和方法，类与类之间有关系，这种关系就是继承。同时，子类还有拥有父类所不具有的属性和方法。父类，也称为基类、超类（superclass）；子类，也称为派生类。
　继承就是通过现有的类构建出新类的机制。类与类之间的继承关系是单继承，一个java类只能有一个父类。
2.如何完成一个继承关系？
　“继承”使用关键字extends
　　格式: public class 子类名称 extends 父类名称{}
　　class 子类名称 extends 父类名称{}
　　前提是父类一定是存在的。

public class Person {
}

public class Student extends Person{
}

3.子类对象创建过程
　子类对象创建–子类的构造方法中会默认调用父类的无参数构造方法【没有父就没有子】
　子类的构造方法中,如果一定要访问父类有参数的构造方法，就需要在子类的构造方法中的第一行通过“super(参数值)”，就可以指定调用父类的任意一个构造方法。

public class Person {
	public Person(){
		System.out.println("父类无参数构造方法");
	}
}

public class Student extends Person{
	public  Student(){
		//隐藏了super();
		System.out.println("子类无参数的构造方法");
	}
}

等价于

public class Person {
	public Person(){
		System.out.println("父类无参数构造方法");
	}
}

public class Student extends Person{
	public Student (){
		super(); //父类无参数构造方法
		System.out.println("子类无参数的构造方法");
	}
}

package com.wangxing.zyb3;
public class Main1 {
	public static void main(String[] args) {
		//测试子类的构造方法
		new Student();
	}
}

　总结:创建子类对象需要子类的构造方法，通过子类构造方法创建子类对象是默认会调用父类的无参数构造方法，当父类没有无参数构造方法时，我们应该在子类的构造方法中的第一行通过super(参数)，调用父类有参数得构造方法来完成子类对象的创建。
4.关于java包
　java包–java程序包
　java中如何创建一个包？
　　通过package关键字创建包
　　格式: package 包名称; [类的第一行]
　java中包的作用是什么？
　　区分名称相同的Java类
　　我们在使用java类的时候需要先导入这个java类所在的包。
　怎们导包？
　　通过import关键字导入需要使用的java包
　　例如:import 包名+类名; //只导入当前包中的当前类
　　例如:import 包名+*; //导入当前包中的所有类
　　包名可以是一个合法的标识符，也可以是多个合法标识符之间用"."分割
　　规则：公司域名倒置.项目.功能
　　注意:1.java.lang包不需要导入。[java.lang包包含的java的核心开发类，系统默认自动导入]
5.java中的访问限制修饰符的区别和用法？
　访问限制修饰符----public【公共的】 缺省的【友好的】 protected【受保护的】 private【私有的】
　类中—public【公共的】 缺省的【友好的】
　1.public修饰的类任何地方都可以访问。
　2.缺省的【友好的】修饰的类跨包不能访问。
　　类中变量–public【公共的】 缺省的【友好的】 protected【受保护的】 private【私有的】
　　类中方法–public【公共的】 缺省的【友好的】 protected【受保护的】 private【私有的】

修饰符	同一个类中	同一个包中的非子类	同一个包中的子类	不同包子类	不同包非子类
public	可以	可以	可以【能继承】	可以【能继承】	可以
protected	可以	可以	可以【能继承】	可以【能继承】	不可以
缺省的	可以	可以	可以【能继承】	不可以	不可以
private	可以	不可以	不可以	不可以	不可以

例如:

package com.wangxing.zyb4;
public class TestClass {
	//类中变量--public【公共的】  缺省的【友好的】  protected【受保护的】 private【私有的】
	public String publicBL="公共的";
	String queshengBL="缺省的";
	protected String protectedBL="受保护的";
	private String privateBL="私有的";
	public void testMedthod1() {
		System.out.println("publicBL=="+publicBL);
		System.out.println("queshengBL=="+queshengBL);
		System.out.println("protectedBL=="+protectedBL);
		System.out.println("privateBL=="+privateBL);
	}
}

package com.wangxing.zyb4;
public class TestSunClass extends TestClass{
	public void testMedthod1() {
		System.out.println("publicBL=="+publicBL);
		System.out.println("queshengBL=="+queshengBL);
		System.out.println("protectedBL=="+protectedBL);
		//System.out.println("privateBL=="+privateBL);
	}
}

package com.wangxing.zyb4;
public class OtherClass {
	public void testMedthod1() {
		TestClass tc=new TestClass();
		System.out.println("publicBL=="+tc.publicBL);
		System.out.println("queshengBL=="+tc.queshengBL);
		System.out.println("protectedBL=="+tc.protectedBL);
		//System.out.println("privateBL=="+tc.privateBL);
	}
}

package com.wangxing.zyb5;
import com.wangxing.zyb4.TestClass;
public class OtherClass {
	public void testMedthod1() {
		TestClass tc=new TestClass();
		System.out.println("publicBL=="+tc.publicBL);
		//System.out.println("queshengBL=="+tc.queshengBL);
		//System.out.println("protectedBL=="+tc.protectedBL);
		//System.out.println("privateBL=="+tc.privateBL);
	}
}

package com.wangxing.zyb5;
import com.wangxing.zyb4.TestClass;
public class TestSunClass extends TestClass {
	public void testMedthod1() {
		System.out.println("publicBL=="+publicBL);
		//System.out.println("queshengBL=="+queshengBL);
		System.out.println("protectedBL=="+protectedBL);
		//System.out.println("privateBL=="+privateBL);
	}
}

package com.wangxing.zyb4;
public class Main1 {
	public static void main(String[] args) {
		TestClass tc1=new TestClass();
		tc1.testMedthod1();
		OtherClass oc1=new OtherClass();
		oc1.testMedthod1();
		TestSunClass tsc=new TestSunClass();
		tsc.testMedthod1();
	}
}

6.Java中子类的继承性
　1.java中的类是单继承。[一个java类只能继承一个父类]
　2.同一个包中子类可以继承父类中除过private修饰的变量/方法。
　3.不同包中的子类可以继承父类中public/protected修饰的变量/方法。
　4.子类中的变量和方法，有一部分是子类从父类继承的，还有一部分是子类自己创建。
　5.定义的java类如果没有明确的继承某个类，那么这个类默认继承了java.lang.Object类。
7.成员变量的隐藏
　1.在同一个类中，局部变量的名称与某一个成员变量的名称相同

public  class Person{
	//成员变量
	public  String  name="zhangsan";
	public  void  testmethod(){
		char  name='A'; //局部变量
		System.out.println("name=="+name); //A [成员变量的隐藏]	
		//需要强制使用被隐藏的成员变量，this访问
		System.out.println("name=="+this.name);
	}
}

2.在子类中的某一个成员变量的名称与父类某一个成员变量的名称相同

public class Person {
	//成员变量
	public  String  name="person";
}

public class SunClass extends Person{
	//成员变量
	public char name='好';
	public void  testMethod(){
		System.out.println("name=="+name); //好 [成员变量的隐藏]
		//需要强制使用被隐藏的成员变量，super访问
		System.out.println("name=="+super.name); //person
	}
}

package com.wangxing.zyb6;
public class Main1 {
	public static void main(String[] args) {
		SunClass sc1=new SunClass();
		sc1.testMethod();
	}
}

8.方法重写
　在子类中某一个方法与父类中的某一个方法相同，此时就是子类重写父类的方法。

public class Person {
	public  void  testInfo(){
		System.out.println("Person的实例方法");
	}
}

public class SunClass extends Person{
	//方法重写
	public void  testInfo(){
	   System.out.println("SunClass的实例方法");
	}	
}