构造方法

最新推荐文章于 2022-07-26 16:33:58 发布

北溟有渔1024

最新推荐文章于 2022-07-26 16:33:58 发布

阅读量459

点赞数

分类专栏：基础课程

本文链接：https://blog.csdn.net/qq_35671247/article/details/116767328

版权

基础课程专栏收录该内容

7 篇文章 0 订阅

订阅专栏

什么是构造方法？

1.含义

构造方法是一种特殊的方法，他是一个与类同名且不需要返回值的方法
作用：当创建对象的时候进行调用，初始化成员变量属性
当类进行实例化对象的时候会自动调用构造方法
注意：
1.构造方法也可以重载
2.如果没有构造方法，系统会提供一个默认的无参构造方法
3.如果没有显示的写出无参构造方法，而有一个有参构造，有参构造会把无参构造覆盖

1.1形式

可以有参，也可以无参

修饰符  类名（参数列表）{
	代码...
}

		package day02;
	
		public class constructionDemo {
		String name;
		int age;
		public constructionDemo() {
			
		}
		public constructionDemo(String name,int age) {
			this.name=name;
			this.age=age;
		}
		
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
		public static void main(String[] args) {
			constructionDemo cd =new constructionDemo();
			System.out.println(cd.name);
			System.out.println(cd.age);
			
			constructionDemo cd1 =new constructionDemo("张三",18);
			System.out.println(cd1.name);
			System.out.println(cd1.age);
			
			constructionDemo cd2=new constructionDemo();
			cd2.setName("李四");
			cd2.setAge(20);
			System.out.println(cd2.name);
			System.out.println(cd2.age);
			
		}
		
	
	}

this 关键字

2.含义

this代表本类对象的一个引用对象
构造函数中，this()方法要放在第一行

	package day02;
	//this演示
	public class Animal {
	String name;
	
	public static void main(String[] args) {
		Animal a=new Animal();
		a.run("大黄");
		System.out.println(a.name);
	}
//	public void run(String n) {
//		name=n;		
//	}

	public void run(String name) {
		
		name=name;
		
	}

}

作用：当局部变量和成员变量同名时，用来区分
如果附近有同名变量，会遵守就近原则相当于局部变量给局部变量赋值
name=name; 除非使用this关键字

2.1 构造方法之间的调用

package day02;
//this演示2
public class dog {
	public dog() {
		this("旺财");
	}

	public dog(String name) {
		System.out.println(name);
	}
	public static void main(String[] args) {
		dog d=new dog();
		
	}
	
}

3. 继承

继承是面向对象的一大特征（封装，继承，多态）
继承指的是从已有的类中派生出新的类，新的类能吸收已有的类的数据属性和行为
并从之前的基础上扩展出新的能力

3.1 继承的特点

1.使用extends关键字进行继承
2.相当于将父类的功能复制了一份
3.java中继承存在着单一性，也就是单一继承
4.继承存在着传递性
5.继承不能继承父类的私有属性
6.继承主要是用于功能的扩展

package day02;

public class inheritDemo {
	public static void main(String[] args) {
		zi z=new zi();
		System.out.println(z.name);
		System.out.println(z.addr);
		z.sing();
		//z.age
		fu f=new zi();
		f.eat();
	}

}
class fu{
	private int age=18;
	String name="黄种人";
	String addr="成都";
	public void sing() {
		System.out.println("和我在成都的街头走一走");
	}
	void eat() {
		System.out.println("爸爸吃饭了");
	}
	
}
class zi extends fu{
	public void eat() {
		System.out.println("儿子吃饭了");
	}
}

注意：
父类的所有功能都能继承过来，除了私有的。（每个人都有点小秘密）
父类的私有属性不能被重写

3.2 Super用法

super英文翻译过来是向上，即代表父类的引用对象

package day02;
//Super的演示
public class superDemo {
	public static void main(String[] args) {
		B b=new B();
		
		
	}
}
class A{
	public A() {
		System.out.println("A的无参构造方法");
	}
}
class B extends A{
	public B() {
		super();
		System.out.println("B的无参构造方法");
	}
	
}

3.3 this和super的区别

1.this指代的是本类对象的引用 super指代的是父类对象的引用
2.this是用于区别局部变量和成员变量
3.super是用于区别本类变量和父类变量
4.this和super不能出现在同一个构造函数中，因为他俩都得放在构造函数的第一行，到底先放哪个？

4.static

含义：static是一个java中的关键字
修饰成员（成员变量和成员方法）

特点：
1.可以修饰成员变量和成员方法
2.随着类的加载而加载，优先对象进行加载
3.只加载一次，就会一直存在，不再开辟新的空间
4.全局唯一，全局共享
5.可以直接通过类名调用
6.静态的只能调用静态的，非静态的可以随意调用
7.static不能与this和super一起使用，因为有static时可能还没有对象

package day02;

public class staticDemo {
	static {
		System.out.println(111);
	}
	public static void main(String[] args) {
		//优于对象加载有没有对象都有static
		int i=Student.age;
		System.out.println(i);
		
		Student s=new Student();
		Student s1=new Student();
		
		System.out.println(s.name);
		System.out.println(s.age);
		System.out.println("-----------");
		System.out.println(s1.age);
		s1.age=20;
		System.out.println(s.age);
		
//		s.eat();
//		s.speak();
		
		
	}

}
class Student{
	String name="张三";
	static int age=18;
	public void eat() {
		System.out.println("eat...");
	}
	public static void speak() {
		System.out.println("speak...");
	}
}

在这里插入图片描述

4.1 静态调用关系

静态的只能调用静态的东西（变量或方法）非静态的可以访问所有的不管是不是静态的

package day02;

public class Teacher {
	String name="张三";
	static int age=30;
	public void speak() {
		 System.out.println(age);//非静态能调用静态变量
         System.out.println(name);//非静态能调用非静态变量

	}
	public static void run() {
		System.out.println(age);//静态能调用静态
		System.out.println(name);//静态不能调用非静态变量，只能调用静态变量
//      speak();//静态不能调用非静态方法，只能调用静态方法
	}
	public static void main(String[] args) {
		Teacher t=new Teacher();
		
	}

}

4.2 静态代码块

随着类的加载而加载，并且只被加载一次，一般用于项目的初始化
static{…}

5. final

概念

是java提供的一个关键字
final是最终的意思
final可以修饰类，方法，成员变量

特点
1、被final修饰的类，不能被继承
2、被final修饰的方法，不能被重写
3、被final修饰的变量是个常量，值不能被更改
4、常量的定义形式： final 数据类型常量名 = 值

//final的演示
public class FinalDemo {
	public static void main(String[] args) {
		
	}
}

//演示final修饰类
final class Hoo{}
//class Ioo extends Hoo{} //编译错误，final的类不能被继承
class Joo{}
final class Koo extends Joo{} //正确，不能当老爸，但能当儿子


//演示final修饰方法
class Foo{
	final void show() {}
	void test() {}
}
class Goo extends Foo{
	//void show() {} //编译错误，fianl的方法不能被重写
	void test() {}
}


//演示final修饰变量
class Eoo{
	final int num = 5;
	void show() {
		//num = 8; //编译错误，final的变量不能被改变
	}
}

6.访问控制修饰符:-------------保护数据的安全

1)public:公开的，任何类
2)private:私有的，本类
3)protected:受保护的，本类、派生类、同包类
4)默认的：什么也不写，本类、同包类
说明:
1)类的访问修饰符只能是public或默认的
2)类中成员的访问修饰符如上4种都可以

public class Aoo {
	public int a;     //任何类
	protected int b;  //本类、派生类、同包类
	int c;            //本类、同包类
	private int d;    //本类
	
	void show() {
		a = 1;
		b = 2;
		c = 3;
		d = 4;
	}
}

class Boo{   //演示private
	void show() {
		Aoo o = new Aoo();
		o.a = 1;
		o.b = 2;
		o.c = 3;
		//o.d = 4; //编译错误
	}
}

package oo.day05.vis;
import oo.day05.Aoo;
public class Coo {    //演示同包的
	void show() {
		Aoo o = new Aoo();
		o.a = 1;
		//o.b = 2; //编译错误
		//o.c = 3; //编译错误
		//o.d = 4; //编译错误
	}
}

class Doo extends Aoo{ //跨包继承----演示protected
	void show() {
		a = 1;
		b = 2;
		//c = 3; //编译错误
		//d = 4; //编译错误
	}
}

7.抽象类

概念：
Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。
抽象类可以理解为是一个只有方法声明没有方法体的特殊类。
举例：水果，东西。。

修饰符 abstract 返回值 方法名(参数列表);
 
class A{
       public void eat(){//声明一样，可以提取
              syso("eat...B")    }
}
class B{
       public void eat(){//声明一样，可以提取
       syso("eat。。。A")   }
}            
abstract class C{
              public abstract void eat();
}

特点：
1、通过java关键字abstract实现
2、可以修饰方法或者类
3、抽象类中可以没有抽象方法（由子类去实现）
4、如果类中有抽象方法，那该类必须定义为一个抽象类
5、子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
6、多用于多态中
7、抽象类不可以被实例化

package day009;
 
public class Test1_Animal {
       public void eat(){
              System.out.println("吃饭饭");
       }
}
/*
 * 每种动物都需要吃，
 * 发现了，方法声明都一样，只是方法体不一样
 *
class Dog extends Test1_Animal{
       public void eat(){
              System.out.println("狗吃肉");
       }
}
 
class Cat extends Test1_Animal{
       public void eat(){
              System.out.println("猫吃鱼");
       }
}*/
 
//上面的eat()声明都一样，就是方法体不一样，那就只抽取方法声明部分。
//The type Animal must be an abstract class to define abstract methods
 abstract class Animal extends Object{
        //This method requires a body instead of a semicolon
       public abstract  void eat();
}
 
 //继承抽象类，并实现抽象方法
//The type Dog must implement the inherited abstract method Animal.eat()
abstract class Dog extends Animal{
     //可以实现抽象方法，也可以子类再变成一个抽象类
}
 
class Cat extends Animal{
       public void eat() {
              System.out.println("猫吃鱼");
       }
      
}

7.1 抽象类的用法

7.1.1 构造函数

抽象类也有构造方法，但是不能本身实例化。
那抽象类的构造函数有啥用？一般用于给子类实例化

package day009;
 
//抽象类的构造方法
public class Test2_Animal2 {
 
}
abstract class Animal2{
       //抽象类可以有构造方法，但是无法实例化
       //用于子类实例化
       public Animal2(){
              System.out.println("fu..Animal2()");
       }
}
class Zi2 extends Animal2{
      
}
 
class TestAnimal2{
       public static void main(String[] args) {
//           Animal2 a2 = new Animal2();//抽象类无法实例化   
//           Zi2 z=new Zi2();//创建子类实例化对象
 
              Animal2 a2 = new Zi2();//抽象类多用于多态    
       }
}

7.1.2 抽象类的成员变量

既可以有变量，也可以有常量。

package day009;
//成员变量
public class Test3_Animal3 {
 
      
}
 
abstract class Animal3{
       //String name;  //1
       //String name="大黄";  //2
       private String name="大黄";  //3
       public final int age=10;
      
       //3.1如果是私有变量想要取值，就提供getXxx()
       public String getName(){
              return name;
       }
}
 
class Zi3 extends Animal3{
      
}
 
class Test3Demo{
       public static void main(String[] args) {
              Animal3 a = new Zi3();//抽象类多用于多态
              //System.out.println(a.name());  //1或者2
              System.out.println(a.getName());  //3
              System.out.println(a.age);
             
       }
}

7.1.3 抽象类的成员方法

抽象类里，既可以有普通方法，有可以有抽象方法。

package day009;
//成员方法
public class Test4_Animal4{
}
 
abstract class Animal4{
       //抽象类中的普通方法
       public void speek(){
              System.out.println("fu...speak()");
       }
       //抽象类里的抽象方法
       public abstract void study();
}
 
class Zi4 extends Animal4{
       //重写抽象方法
       public void study(){
              System.out.println("zi...study()");
       }
}
 
class Zi4Test{
       public static void main(String[] args) {
              Zi4 z= new Zi4();
              z.speek();//fu...speak()
              z.study();//zi...study()
       }
}

8. 接口

8.1概念

Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。
Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性，就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。
interface 接口名{ 代码… }

8.2 特点

1、接口中都是抽象方法
2、通过interface关键字创建接口
3、通过implements让子类来实现
4、可以理解成，接口是一个特殊的抽象类
5、接口突破了java的单继承的局限性
6、接口和类之间可以多实现，接口和接口之间可以多继承
7、接口是对外暴露的规则，是一套开发规范
8、接口提高了程序的功能扩展，降低了耦合性

入门案例：

package day9999;
public class T {
       public static void main(String[] args) {
              Zi z = new Zi();
              z.study();
              z.teach();
       }
}
interface Fu{
       public abstract void study();
       public abstract void teach();
}
//实现+重写
class Zi implements Fu{
       public void study(){
              System.out.println("Zi..study()");
       }
       public void teach(){
              System.out.println("Zi..teach()");
       }
}

8.3 接口的用法

8.3.1 构造方法

接口里是没有构造方法的。
在创建实现类的对象时默认的super()，是调用的默认Object的无参构造。

interface Fu{//定义一个接口
       public abstract void show();
       //Interfaces cannot have constructors
       /*public Fu(){
              System.out.println("Fu.Fu()");
       }*/
}

8.3.2 成员变量

接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：
public static final

package day009;
//构造函数，成员方法，成员变量
public interface Test7_Fu {
 
}
interface Fu2{//定义一个接口
      
       //int num=10;//1,成员变量
       //static int num=10;//2,默认就是静态的
       //final static int num=10;//3,默认就是final的
       public final static int num=10;//4,默认就是public的
 
class Zi7 implements Fu2{
 
}
 
class Test7Demoo{
       public static void main(String[] args) {
              Zi7 z= new Zi7();
              //The final field Fu2.num cannot be assigned
              //z.num=30;//默认是final的，不能修改值
              System.out.println(z.num);
              System.out.println(Fu2.num);
       }
}

8.3.3 接口的成员方法

接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。
例如：abstract void save

8.3.4 接口和抽象类的区别

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2、抽象类要被子类继承，接口要被类实现。
3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
6、抽象方法只能申明，不能实现，接口是设计的结果，抽象类是重构的结果
7、抽象类里可以没有抽象方法，如果要扩展抽象类的新方法，子类将很容易的就能得到这些新方法。
8、如果一个类里有抽象方法，那么这个类只能是抽象类
9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
10、接口可继承接口，并可多继承接口，但类只能单根继承。