Java学习博客第一篇

面向对象：

面向对象思想理解：
面向对象时基于面向过程的一种编程思想面向过程：关注点在于实现功能的细节，需要亲自一步一步的去完成（自己做 ）
关注点在于对象身上，对象可以帮助我们去完成具体的功能（让别人帮你做）
面向对象举例：
喝水：
面向过程：自己烧水–>倒在杯子里–>喝水
#面向对象：饮水机（对象）

面向对象的底层实现还是基于面向过程。
面向特点
1)更符合日常的生活习惯
2)把复杂的问题简单化
3)把我们从执行者变为指挥者

类与对象类：

类是对同一类事物的描述如电脑类、手机类、学生类、老师类…【可以理解为同一类事物的统称】
对象：对象是类的具体体现如一个电脑对象，一个手机对象，一个学生对象…【对象是类的具体实例，生活中万物皆对象】
一句话总结：类是对象的模板，对象是类的具体实例。
类的定义：
定义类的格式

public class 类名{
//成员变量–属性
//成员方法–行为
}	
//类名：见名知意（名词）		
public class Student{			
//成员变量--属性			String name;			int age;			//成员方法--行为			public void eat(){
//不要有static关键词修饰				System.out.println("学生吃饭");			
}				
public void study(){			
System.out.println("学生学习");		
}	}
创建对象的格式：类名 对象名=new 类名();
//参数的有无依据是否创建有参构造器/无参构造器	
//测试类（有main方法的类）	
public class Demo1{		
public static void main(String[] args){			//创建Student对象 			
//类名 对象名=new 类名();			
Student  stu=new Student();  
//类也是一种引用数据类型						stu.name="张三";			
stu.age=18;			

System.out.println(stu.name); //张三			

System.out.println(stu.age);  //18						//学生对象 调用 eat()方法			
stu.eat();			
//学生对象 调用 study()方法			

stu.study();		
}	}对象的内存

成员变量和局部变量的区别：
1.在类中的位置不一样
1)成员变量：类的{ }里面
2)局部变量: 在方法的{ }里面或者方法()里（方法的参数也是该方法的局部变量）
2.初始化值(默认值)不同
1)成员变量：有默认的初始值(和array类的各数据类型的默认初始值相同)
2)局部变量：没有默认的初始值,如果要想使用，必须手动进行赋值
3.作用域不同
1)成员变量：在整个类中有效
2)局部变量：只在定义的方法中有效
4.内存位置不同
1)成员变量: 在堆内存中
2)局部变量：在栈内存中

封装性封装：

把不需要让别人知道的内部细节隐藏，提高程序的运行的安全性，提供公共的访问方式。

private关键字：
被private修饰的变量，只能在本类中访问
1)使用private修饰成员变量
2)提供getXxx和setXxx间接的访问成员变量

this关键字:
当成员变量和局部变量重名时，可以使用this来区分因为当局部变量和成员变量重名时，方法会优先使用自己的局部变量，如果两个变量都想用，就通过this关键字来区分，不重名就不用

在这里插入代码
this.成员变量	访问本类的成员变量
//(标明这个name变量是本类的成员变量)
this.成员方法	调用本类的成员方法
//表示(通过对象的地址调用)谁调用这个方法，那么这个方法内部的this就是谁的	

构造方法(构造器)

1.构造方法的格式（就是方便类自己创建对象）

2.构造方法干什么用的？
构造方法就是用来创建对象的

类名 变量  = new  类名();-->就会执行无参构造器	
类名 变量 = new 类名(参数列表);-->就会执行有参构造器

3.构造方法的注意事项
1)如果我们没有写构造方法，系统会默认赠送一个空参数的构造方法
(所有我们可用直接在main方法中直接写：类名 变量 = new 类名();应为系统会默认赠送一个无参构造器)
2)如果我们写了构造方法，系统不会赠送空参数构造方法，为了防止报错最后把有参构造器和无参构造器都写上
3)有(全)参构造器的作用方便在创建对象时给成员变量赋值，set方法的作用是方便在后期修改数据(修改成员变量的值)
4)提供多种构造器，有多种创建对象的方式。
无参构造器的作用，就是我们在创建对象的目的不一定时要给成员变量赋值，也有可能只是想通过无参构造器创建的对象来调用该类所提供的方法无参构造器和有参构造器的应用，在实际开发过程中更具自己的需求合理使用new一个对象就是在执行构造方法

Scanner类

Scanner是用于做键盘录入的类
//1.在java.util包下，需要导包
import java.util.Scanner;
注意: 写在类名的上面
//2.创建Scanner对象
Scanner sc=new Scanner(System.in);
//3.获取键盘录入数据，通过对象调用Scanner类提供的nextInt()方法实现键盘录入一个int类型的数值int num=sc.nextInt();
//获取键盘录入的int数据，(因为nextInt方法返回的是一个int类型的结果所以要用int类型的变量来接收)
int num1 = sc.nextDouble();
//获取键盘录入的double类型的数据
String str=sc.next();
//获取键盘录入的字符串，如果遇到一个空格就会结束录入，这样空格后面的字符串就不会被录入scanner.nextLine();
//获取键盘录入的一行字符串(可含有空格)

Random类

Random是用来生成随机数的类
//1.导包(自动完成)import java.util.Random;
//2.创建Random对象
Random r=new Random();
//3.生成随机数，通过对象调用Random类提供的nextInt()方法实现
生成一个随机数
int num1=r.nextInt();
//整个int范围内的随机数
int num2=r.nextInt(10);
//[0,10)范围内的随机数，从0开始
int num2=r.nextInt(100)+1;
//[0,100) +1 --> [1,100] 范围内的随机数
//生成范围在[51,100]中的随机数
int num3=r.nextInt(51)+50;

继承

关键词：extends
implements 是实现接口的关键词
理解：解决多子类中【共性抽取】的问题，提高了代码的复用性。

1.继承的格式
public class Father{
	//成员变量；
	//构造方法	
	//成员方法
}
public class Son extends Father{
	//成员变量	
	//构造方法	
	//成员方法
}

2.继承中成员的访问特点
1)成员变量的访问特点如果欲访问的变量，子类中存在就先访问子类中的这个变量，如果没有就访问父类，如果父类也没有，就报错。
this.成员变量—>指明访问本类的成员变量
super.成员变量—>指明访问父类的成员变量
2).成员方法的访问特点子类有就先用子类的，子类没有就用父类的，如果父类也没有就报错。

方法重写（复写/覆盖）：
在子类父类关系中有一模一样的方法。
方法重写的注意事项：
1).@Override:注解，起到标记提示的作用写在方法上面，起到检测方法是否正确覆盖如果没有就报红提示，其实就算不写，如果方法没问题也能完成对父类相同方法的覆盖
2).重写方法的返回值类型的范围，必须【小于等于】父类返回值类型的范围
3).重写方法的权限修饰符的范围，必须【大于等于】
父类返回值类型的范围
public > protected > 默认的(default不用写出来) > private1
【小结：实际运用方法重写，只需要和父类写得一模一样就可以了】
方法重写的好处：既能保证父类的方法不变，子类也可以根据自己的需求做不同的实现。

代码案例：
public class Phone{				
	public void show(){	
		System.out.println("来电显示");					
		}				
}								
public class NewPhone extends Phone{					

@Override//提示该方法是重写父类的show方法					
public void show(){						super.show(); //调用父类方法						
System.out.println("显示头像");						System.out.println("显示姓名");					
}				
}

3)构造方法的访问特点
a:子类所有的构造器(构造方法)都会默认去访问父类的空参构造器在构造方法的第一行隐含的一句super()；访问父类的空参构造方法
b:如果父类没有空参构造器，子类可以通过super(参数)；去调用父类的有参构造器

3.this和super的用法总结
super：引用父类对象
super.成员变量 调用父类的成员变量(用来访问父类被隐藏的成员变量即就是private关键字修饰的成员变量只能被间接访问)
super.成员方法 调用父类的成员方法(调用父类中被重载的方法)
super() 调用父类的空参构造器
super(参数) 调用父类的有参构造器
this：访问(调用)当前类的对象
this.成员变量 访问当前类的成员变量this.成员方法 调用当前类的成员方法
this() 访问当前类的空参构造器
this(参数) 访问当前类的有参构造器
注意：不管是 this()、 super() 还是 this(参数)、 super(参数) 只能写在构造方法的第一语句即super()和this的用法一样的在构造方法中：都必须得是第一行，所以二者不可共存
super用法注意：在子类的构造方法中调用父类构造方法只能访问一次即子类中：不能同时存在super()，和super(参数)两条语句

4.继承的特点
1)Java只能单一继承一个儿子只能有一个爸爸
2)Java支持多层继承爸爸也可以有爸爸
3)一个类可以有多个子类爸爸可以有多个儿子