Java学习笔记

1.多组输入

import java.util.*;
class Input
{
	public static void main(String[] args){
		Scanner input=new Scanner(System.in);
		while(input.hasNext()){//多次输入
			int n=input.nextInt();
			System.out.println(n);
		}
	}
}

2.static关键字：
        static关键字可以修饰属性：（所有对象的相同属性）
                ----该属性在方法区中开辟空间，并且所有对象都可以访问。
                ----与类同生死，生命周期比较长
                ----优先于对象
                ----访问时可以直接使用 类名.属性名 或 引用名.属性名
                ----引用为null,也可以访问静态属性
        好处：节省空间

class Student3{
	//非静态属性，创建对象后存在(也叫实例属性）
	String name;

	//静态属性，也叫做类的属性，优先于对象存在
	static String address;
	static{//静态代码块  
		address="北京市";
	}

	//静态方法，也叫做类的方法
	public static void print(){
		System.out.println("OK！");
		//System.out.println(name);报错
		//静态方法不能引用非静态变量
	}
}
class Student3Test
{
	public static void main(String[] args){
		 //未创建对象也可访问
		 System.out.println(Student3.address);//北京市
		 Student3.print();
		 //创建对象为null
		 Student3 a=null;
		 System.out.println(a.address);//不报错，输出”北京市“
		 a.print();
	}
}

3.方法重载：

•    在同一个类中，必须方法名称相同，参数列表不同（类型/个数/顺序不同），与返回值类型无关。
•    调用时根据参数类型自动匹配相应方法。

class ChongZai
{
	//max函数重载
	public static int max(int a,double b){
		return a>b?a:(int)b;
	}
	public static double max(double a,int b){
		return a>b?a:b*1.0;
	}
	public static void main(String[] args){
		System.out.println(ChongZai.max(1,3.0));//匹配第一个，输出3
		System.out.println(ChongZai.max(2.0,1));//匹配第二个，输出2.0
	}
}

4.面向对象

概念：采用虚拟世界“模拟现实”生活，必须保证模拟一致；

• 类：对同一事物的抽象描述（电脑类、学生类、、、）
• 对象：具体的实例（我的电脑）
• 类与对象的关系：抽象和具体的关系
• 属性：对象的特征
• 方法：对象做的事

import java.util.*;
class Computer//Computer类
{
	//属性也叫成员变量
	String color;
	String brand;
	double price;

	//构造方法(方法名必须是类名)----无参构造
	public Computer(){
		Scanner input=new Scanner(System.in);
		this.color=input.next();
		this.brand=input.next();
		this.price=input.nextDouble();
	}
	//构造方法(方法名必须是类名)----带参构造 
	public Computer(String color,String brand,double price){
		this.color=color;
		this.brand=brand;
		this.price=price;
	}
	//构造方法的重载：构造方法名字相同，参数类型不同，调用时自动匹配执行

	//方法：显示成员信息
	public  void show1(){
		System.out.println("颜色："+color);
		System.out.println("品牌："+brand);
		System.out.println("价格："+price);
	}
	public void show2(String color){
		//color为与成员变量同名的局部变量；
		System.out.println("输出局部变量color："+color);//局部变量优先，输出蓝色
		System.out.println("输出成员变量color："+this.color);//指定成员变量，输出银色
		this.color=color;//局部变量给成员变量赋值；
		System.out.println("被局部变量赋值后的成员变量color："+this.color);
	}
}
class ComputerTest
{
	public static void main(String[] args){
		Computer c=new Computer();//自己输入
		c.show1();
		Computer cc=new Computer("银色","Xiaomi",4999);//赋值
		cc.show2("金色");
		//cc=null;引用名称为null则无法访问对象属性，会出现空指针异常
	}
}

5.封装

作用：隐藏类的内部信息，不允许外部程序直接访问（筛选）
操作步骤：
                 1.属性设置为私有，只能在本类使用
                 2.设置属性的get取值和set赋值方法
                 3.set里面适当编写判断语句

//编写学生类
class Student2{
	//属性
	String name;
	//封装第一步：将属性设为私有（只能在当前类中使用）
	private int age;
	char sex;
	

	//封装第二步：编写对应属性的赋值方法set
	public void setAge(int age){
		if(age>0&&age<100)
			this.age=age;
		else
			this.age=18;//默认18
	}

	public void show(){
		System.out.println("姓名："+name+"
年龄："+age+"
性别："+sex);
	}
}
//编写测试类
class Student2Test
{
	public static void main(String[] args){
		Student2 s=new Student2();
		s.name="AEIP";
		s.sex='男';
		s.setAge(10086);
		s.show();
		//10086年龄和a性别不符合实际，解决办法：赋值前对值判断，合法才能赋值
	}
}

6.继承

在java中，子类继承父类，好处：减少代码冗余性

注意：

• 子类继承除构造函数外的父类所有方法属性
• 一个子类只能继承一个直接的父类，称为单根性 
• 父类private属性不能继承
• 创建子类对象时，先跳到子类相匹配的构造方法中，如果子类未指定调用父类哪个构造方法，则默认调用父类无参构造方法。

//编写师生类
class TeaStu
{
	String name;
	char sex;
	int age;
	public void show(){
		System.out.println("姓名："+name+"
性别："+sex+"
年龄："+age);
	}
}
//编写学生类
class Student extends TeaStu{
	int results;
	public Student(String name,char sex,int age,int results){
		this.name=name;
		this.sex=sex;
		this.age=age;
		this.results=results;
	}
	public void show(){
		super.show();
		System.out.println("成绩："+results);
	}
	public void study(){
		System.out.println("学习。。。");
	}
}
//编写教师类
class Teacher extends TeaStu{
	int salary;
	public Teacher(String name,char sex,int age,int salary){
		this.name=name;
		this.sex=sex;
		this.age=age;
		this.salary=salary;
	}
	public void show(){
		super.show();//直接调用父类
		System.out.println("薪水："+salary);
	}
	public void teach(){
		System.out.println("教学。。。");
	}
}
//编写测试类
class Test1
{
	public static void main(String[] args){
		Student s=new Student("aeipyuan",'男',21,88);
		s.show();
		s.study();
		Teacher t=new Teacher("AEIPYUAN",'男',22,9999);
		t.show();
		t.teach();
	}
}

7.多态

•  概念：多个对象调用同一方法得到不同结果
• 语法格式 ：父类类名 引用名 = new 子类类名
• 性质：是多态时，引用名称只能访问父类中的属性和方法，但是优先访问子类重写的方法
• 满足条件：

                      子类必须继承父类

                      子类必须重写父类方法

• 多态好处： 减少代码冗余性

•  两种类型转换：

                       1)向上转型

                       2)如果想访问子类独有属性和方法，向下转型（强制类型转换）

class Pet
{
	public void eat(){
		System.out.println("正在吃。。。");
	}
}
class Cat extends Pet
{
	public void eat(){
		System.out.println("正在吃鱼。。");
	}
	public void catching(){
		System.out.println("抓老鼠。。。。。");
	}
}
class Dog extends Pet
{
	public void eat(){
		System.out.println("正在啃骨头。。。");
	}
}
class Master
{
	public void feed(Pet pet){
			pet.eat();
	}
}
class Test11
{
	public static void main(String[] args){
		Master m=new Master();
		m.feed(new Cat());//根据new的内容不同调用不同的子类
		m.feed(new Dog());

		Pet p=new Cat();//构成多态，向上转型
		p.eat();
		//p.catching();//报错，多态不能访问子类独有属性和方法
		Cat cat=(Cat)p;//向下转型（强制类型转换）
		cat.catching();
		//Dog dog=(Dog)p;
		//报错，引用名称不符合Dog类型，防止报错可以先判断if(p instanceof Dog);
	}
}