Java基础之面向对象相关知识点

最新推荐文章于 2023-07-10 15:31:57 发布

原创最新推荐文章于 2023-07-10 15:31:57 发布 · 302 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#面向对象 #java基础之面向对象 #面向对象相关知识点

java 专栏收录该内容

47 篇文章

订阅专栏

成员方法：

类的组成中有一个成员：成员方法
成员方法的分类：
1)按照返回值划分：
void的形式:没有具体的返回值；
非void形式:有具体返回值；
2)按照参数进行划分：
无参；

有参；

举例：

//创建一个学生类
class Student {
	
	private String name ;
	private String age ;
	
	public Student() { //alt+shift+s+c
	}
	
	//成员方法
	public String show() { //有返回值没有参数的
		return "helloworld" ;
	}
	
	//没有返回值,有参数的情况
	public void method(String s) {
		System.out.println(s);
	}
	
	//没有返回值,没有参数的情况
	public void function() {
		System.out.println("function student...");
	}
	
	//有返回值,有参数的情况
	public String function2(String s1,String s2) {
		return s1+ s2;
	}
}

//测试类
public class Test {

	public static void main(String[] args) {
	
		//创建学生类对象
		Student s = new Student() ;
		
		String str = s.show() ;
		System.out.println(str);
		s.method("Java");
		s.function();
		String str2 = s.function2("hello", "world") ;
		System.out.println(str2);
		
	}
}

构造方法：

        构造方法作用：
就是给对象进行进行初始化；

        构造方法也属于一类的组成：
成员变量；
构造方法；
成员方法；

        构造方法：
1)方法名和类名相同；

2)构造方法,连void都没有；

举例：

//创建一个学生类
class Student{
	
	//构造方法
	public Student() {
		System.out.println("这是一个无参构造方法...");
	}
}
public class ConstructorDemo {
	
	public static void main(String[] args) {
		
		//创建一个学生对象
		Student s = new Student() ;
		System.out.println(s);//包名.类名@十六进制数据;
	}
}

构造方法的注意事项：
1)之前没有写无参构造,系统会默认提供无参构造；
2)如果我们无参构造或者有参构造,系统不会在提供无参构造;定义一个类的时候,永远给出无参构造；

构造方法是可以重载的；

举例：

//创建一个老师类
class Teacher{
	
	private String name ;
	private int age ;
	
	//SetXXX()/GetXXX()方法:公共访问方法
	
	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 Teacher() {
		System.out.println("老师类的无参构造..");
	}
	
	//有参构造
	public Teacher(String name) {
		this.name = name;
		
		System.out.println("带一个String类型参数的有参构造");
	}
	
	public Teacher(int age) {
		this.age =age ;
		System.out.println("带一个int类型参数的有参构造");
	}
	
	//带两个参数
	public Teacher(String name,int age) {
		this.name =name ;
		this.age = age ;
		System.out.println("带两个参数的有参构造...");
	}
}

//测试类
public class ConstructorDemo2 {

	public static void main(String[] args) {
		
		//创建一个老师类对象
		Teacher t = new Teacher() ; 
		t.setName("张三");
		t.setAge(27);
		System.out.println(t.getName()+"----"+t.getAge());
		System.out.println("----------");
		
		/**
		 * 给成员变量有两种方式:
		 * 	1)setXXX()公共的访问方法
		 * 	2)可以通过有参构造进行赋值
		 */
		t = new Teacher("高圆圆") ; 
		t.setAge(28);
		System.out.println(t.getName()+"----"+t.getAge());
		System.out.println("----------------");
		
		t= new Teacher(27) ;
		t.setName("赵又廷");
		System.out.println(t.getName()+"----"+t.getAge());
		
		System.out.println("----------------");
		
		Teacher t2 = new Teacher("高圆圆", 27) ;
		System.out.println(t2.getName()+"----"+t2.getAge());
		
		
		
		
		
	}
}

形参：

形式参数的问题：
1) 如果是基本数据类型,形式参的改变对实际参数没有影响；
2) 研究引用类型：形式参数的改变会直接影响实际参数；

举例：

class Demo{
	
	//求和的成员方法
	public int sum(int a,int b) { //形式参数是基本类型  :
		return a+b ;
	}
}

//一个学生类
class Student{
	public void show() {
		System.out.println("好好学习,天天向上....");
	}
}

class StudentDemo{
	//method方法中形式参数是一个引用类型:需要的是学生类对象  Student s = new Student () ;
	public void method(Student s) {//形式参数现在引用类型  
		s.show(); 
	}
}

//测试类
public class ArgsTest {
		
	public static void main(String[] args) {
		//创建Demo类对象
		Demo d = new Demo() ;
		System.out.println(d.sum(10, 20)) ;
		System.out.println("-------------------------");
		
		//需求:调用StudentDemo中的method方法:如何调用
		//1)创建StudentDemo类对象
		StudentDemo sd = new StudentDemo() ;
		//2)形式参数是Student类型,所以创建Student类的对象
		Student s = new Student() ;
		sd.method(s);
		
	}
}

匿名对象：

就是创建对象的时候,没有名字的对象；

举例：

//定义一个学生类
class Student{
	
	String name ;
	int age ;
	
	public void show() {
		System.out.println(name+"---"+age);
	}
}

//学生类的测试类
public class StudentDemo {
	
	public static void main(String[] args) {
		
		//创建一个学生类对象
		Student s = new Student() ;//该对象名s
		s.name = "高圆圆" ;
		s.age = 28 ;
		s.show(); 
		
		System.out.println("------------------");
		//匿名对象(开发中经常使用),没有名字的对象
		System.out.println(new Student());//org.westos.noname.Student@70dea4e
		new Student().name = "赵又廷" ;
		
		/**
		 * 匿名对象在实际开发中,只用使用一次,不要使用多次  (可能会造成一个内存溢出的现象);
		 */
		new Student() ; //一直给堆内存开辟空间 
		new Student () ;
		
	}
}

private 用法：

1)被private修饰的只能在本类访问；

2)可以通过公共的访问public 去间接访问；

注意：当前成员变量和局部变量名称一致的情况,遵循就近原则；

举例：

class Demo{
	private int num = 100 ;
	
	//成员方法 :公共访问方法
	public void method()	{
		int num = 200 ; //局部变量
		System.err.println(num);
	}
}
//测试类
public class PrivateDemo {
	
	public static void main(String[] args) {
		//创建一个Demo类的对象
		Demo d = new Demo() ;
//		System.out.println(d.num);//外界不能访问
		d.method(); 
		
	}
}

static 关键字：

        1)静态随着类的加载而加载；
        2)static优先于对象存在；
回想:main public static void main(..){...}
        3)static共享数据,可以被多个对象进行共享；
举例: 饮水机(staticd的:共享的)
水杯(不能共享的...)
        4)如果数据被静态修饰的,它可以被类名直接调用；
被静态修饰的方法: 类名.方法名()
被静态修饰的变量: 类名.变量名;

static 用法：

一个类中可有静态变量,也可以有非静态；
可以有静态成员方法,也可以非静态的成员方法；
静态的方法只能访问静态变量,或者是静态的方法；
非静态的方法,既可以访问静态变量也可以非静态的变量...

简单记:静态只能访问静态

举例:

class Student{
	
	int num = 100 ;
	public static int num2 = 200 ;
	
	public void show() { //非静态的
		System.out.println(num);//隐藏去访问成员变量 ,隐藏了一个关键字:this
//		System.out.println(num2);
		System.out.println(this.num2);//显示的去访问成员变量
		
		function() ;
		
	}
	
	public static void  function() {
//		show() ; 静态只能访问静态方法,不能访问非静态的
		function2() ;
	}
	
	public static void function2() {
		
	}
}

//测试类
public class StaticDemo3 {
	public static void main(String[] args) {
		
		//创建学生类对象
		Student s = new Student() ;
		s.show(); 
		s.function(); 
		s.function2(); 
		
//		method();
		
	}
}

this 关键字：

this：代表是当前类对象,或者是(当前类对象的引用),解决局部隐藏了成员变量；

举例：

//手机类
class Phone{
	
	//私有修饰
	private String brand ;
	private int price ;
	private String color ;
	
	//成员方法
	//提供公共的访问方法
	public void setBrand(String brand) {
//		brand = brand ;
		this.brand = brand;
	}
	
	//获取手机品牌
	public String getBrand() {
		return brand ;
	}
	
	public void setPrice(int price) {
//		price = price ;
		this.price = price ;
	}
	public int getPrice() {
		return price ;
	}
	
	public void setColor(String color) {
		//color = color ;
		this.color = color ;
	}
	public String getColor() {
		return color ;
	}
	
}

//测试类
public class Test {
	
	public static void main(String[] args) {
		
		//创建手机类对象
		Phone p = new Phone() ;
		p.setBrand("华为");
		p.setPrice(1999); 
		p.setColor("黑白");
		
		System.out.println(p.getBrand()+"---"+p.getPrice()+"----"+p.getColor());
		System.out.println("-----------------------");
		
		Student s = new Student() ;
		s.setName("高圆圆");
		s.setAge(28); 
		s.setsId("xx002");
		s.setGender('女');
		s.setTitle("学习委员");
		
		System.out.println(s.getName() + "----" + s.getAge() + "----" + s.getsId() + "----" + s.getGender() + "----"
				+ s.getTitle());
	}
}

成员变量和局部变量的区别：

1)在类中位置不同：
成员变量：类中,方法外；
局部变量：方法声明上,或者再方法定义中；
2)在内存中的位置不同：
成员变量：堆内存；
局部变量：栈内存；
3)生命周期不同：
成员变量：成员变量是随着类的加载而加载,随着类的消失而消失；
局部变量：随着方法的调用而存在,随着方法调用完毕而消失；
4)初始化值不同：
成员变量：初始化由系统默认初始化,
对于成员变量,可以不给初始化值,由系统给,然后显示初始化；
局部变量：定义一个局部变量,必须进行初始化,如果不初始化,无法使用(在使用之前进行初始化)；

举例：

class Variable{
	//成员变量
	int num = 10;
	
	public void show() {
		System.out.println(num);
	}
}

//测试类
public class VariableDemo {
	
	public static void main(String[] args) {
		
		int num2 = 100 ;
		System.out.println(num2);
		//创建Vaiable类对象
		Variable v = new Variable() ;
		//使用对象名去访问这个类中的成员变量和成员方法
		System.out.println(v.num);
		
		v.show(); 
		
		
	}
}