javaSE的学习week03

1. static 关键字

package cn.hncu_01;

/*
 * 需求1:写一个学生类
 * 
 * 问题:
 * 		如果说每一个学生的姓名和年龄都不同,这我可以理解.
 * 		但是,绝大部分学生的国籍都是中国,在每一个对象中,都在堆中开辟一个空间来存放国籍,是不是有点浪费?怎么办?
 * 			用static关键字可以解决这个问题.
 * 
 * static关键字
 * 		1. 可以修饰成员变量,也可以修饰成员方法.
 * 		2. 随着类的加载尔加载.优先于对象存在在内存中.(先加载staict修饰的成员变量和成员方法,再加载对象)
 * 		3. 别类的所有对象共享
 * 		4. 被static修饰的成员变量或成员方法可以通过类名直接调用(也可以通过对象调用).
 * 
 * 注意事项:
 * 		1. 静态方法中没有this关键字.为什么类?
 * 			静态方法是随着类的加载而加载,而this是随着对象的创建而存在.
 * 			静态方法比this先到内存
 * 		2. 静态方法只能调用静态变量.
 */
class Student {
	private String name;
	private int age;
	private static String country = "中国";

	public Student() {

	}
	
	public Student(String name, int age) {
		this.name = name;
		this.age = age;	
	}

	public Student(String name, int age, String country) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public void setCountry(String country) {
		this.country = country;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	public String getCountry() {
		return country;
	}

	public void myPrintf() {
		System.out.println(name + "--" + age + "--" + country);
	}
	
	public static void  myPrintf2() {
		//this.name = "11";
		System.out.println( country);
		//System.out.println(name);
	}
}

public class Demo {
	public static void main(String[] args) {
		/*Student s1 = new Student("班长", 19, "中国");
		Student s2 = new Student("学委", 20, "中国");
		Student s3 = new Student("团委", 20, "中国");
		s1.myPrintf();*/
		Student s1 = new Student("班长", 19);
		Student s2 = new Student("学委", 20);
		s1.myPrintf();
		s2.myPrintf();
		Student.myPrintf2();
	}
}

2. main 方法详解

•public static void main(String[] args) {}

        •public 被jvm调用，访问权限足够大。

        •static 被jvm调用，不用创建对象，直接类名访问

        •void被jvm调用，不需要给jvm返回值

        •main 一个通用的名称，虽然不是关键字，但是被jvm识别

        •String[] args 以前用于接收键盘录入的

3. 继承

package cn.hncu_02;
/*
 * 继承
 * 		通过老师类和学生类我们发现,代码重复度很高,并且还有可能存在许多类似的类,如工人类,医生类等.
 * 		这样写代码不好,而且后期维护起来很麻烦,怎么解决?
 * 		用继承可以解决
 * 1. 什么是继承?
 * 		继承就是把多个类中相同的东西提取出来定义到一个新类中.如何实现?
 * 			用extends关键字.
 * 		格式:
 * 			class 子类名 extends 父类名{}
 * 
 */
class Student {
	public void eat(){
		System.out.println("吃饭");
	}
	public void sleep(){
		System.out.println("sleep");
	}
}

class Teacher {
	public void eat(){
		System.out.println("吃饭");
	}
	public void sleep(){
		System.out.println("睡觉");
	}
}


public class Demo {

}

 

package cn.hncu_03;
/**
 * 通过使用继承,重写学生类和老师类
 * 	格式:
 * 			class 子类名 extends 父类名{}
 **/
class Person {
	public void eat(){
		System.out.println("吃饭");
	}
	public void sleep(){
		System.out.println("sleep");
	}
}

class Student extends Person {
	
}

class Teacher extends Person{
	
}

public class Demo {
	public static void main(String[] args) {
		//测试学生类
		Student s = new Student();
		s.eat();
		s.sleep();
		
		//测试老师类
		Teacher t = new Teacher();
		t.eat();
		t.sleep();
	}
}

package cn.hncu_04;
/*
 * 继承的好处
 * 	(1) 提高了代码的复用性.
 * 	(2) 提高了对面的维护性.
 * 	(3) 让类与类之间产生了关系,是多态的前提(后面讲).
 * 
 * 类与类之间产生关系,其实也是继承的一弊端: 类的耦合性增强了.
 * 
 * 开发原则: 高内聚,低耦合
 * 
 * 内聚:自己独立完成某件事的能力.
 * 耦合:类与类的关系
 * 
 * 	继承的特点:
 * 	(1) java只支持单继承,不支持多继承(类与类之间的继承).
 * 	(2) Java支持多层继承.
 */
class GrandFather{
	
}

class Father extends GrandFather{
	
}

class Mother {
	
}

/*class Son extends Father,Mother  {
	
}*/

class Son extends Father{
	
}

public class Demo {

}

 

package cn.hncu_05;
/*
 * 继承的注意事项:
 * 	子类只能继承父类的非私有成员.私有成员不能继承.
 * 	子类不能继承父类的构造方法,但是可以通过super关键(马上讲)访问父类的构造方法.
 * 	不要为了部分功能而去继承.
 */
class Fu {
	private void fun(){
		System.out.println("fu");
	}
}

class Zi extends Fu {
	
}
public class Demo {
	public static void main(String[] args) {
		Zi zi = new Zi();
		//zi.fun();
	}
}

3.1 继承中成员变量的关系

package cn.hncu_06;

/*
 * 继承中成员变量的关系:就近原则.
 * 
 * 思考:
 * 		我在fun()中,如果要输出父类的number的值,怎么办?
 * 		super关键字
 * 
 * this 和 super的区别是什么?
 * 	this:代表本类的引用.
 * 	super:代表父类引用.
 * 
 * this 和 super的具体用法?
 * 	(1)调用成员变量	
 * 			this.成员变量		调用本类的成员变量
 * 			super.成员变量		调用父类的成员变量
 * 	(2)调用构造方法
 * 			this(...)		调用本类的构造方法
 * 			super(...)		调用父类的构造方法
 * 	(3)调用成员方法
 * 			this.成员方法		调用本类的成员方法
 * 			super.成员方法		调用父类的成员方法
 * 
 */
class Father {
	int number = 10;
}

class Son extends Father {
	int number =100;
	
	public void fun(){
		System.out.println(this.number);
		System.out.println(super.number);
	}
	
	public void fun2(int number){
		System.out.println(number);
	}
}

public class Demo {
	public static void main(String[] args) {
		Son son = new Son();
		//System.out.println(son.number);
		son.fun();
		//son.fun2(1000);
	}
}

3.2 继承中构造方法的关系

package cn.hncu_07;

/*
 *继承中构造方法的关系:
 *	(1) 子类中所有的构造方法都会默认访问父类的无参构造方法.
 *	
 * 如果父类没有无参构造,会出现怎么样的结果?
 * 		报错.
 */
class Father {
	public Father(){
		System.out.println("Father无参构造");
	}
	
	public Father(int x  ){
		System.out.println("Father带参构造");
	}
}

class Son extends Father {
	public Son(){
		System.out.println("Son无参构造");
	}
	
	public Son(int x){
		//super();
		System.out.println("Son带参构造");
	}
	
}

public class Demo {
	public static void main(String[] args) {
		Son son = new Son();
		System.out.println("------------------");
		Son son2 = new Son(22);
		
	}
}