面向过程思想
步骤清晰简单，第一步做什么，第二步做什么。。。
面向过程适合处理一些简单的问题
面向对象
物以类聚，分类的思维模式，首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
面向对象的本质就是：以类的方式组织代码，以对象的组织(封装)数据。
抽象
三大特性：封装，继承，多态
方法回顾和加深
方法的定义
修饰符
返回类型
break：跳出switch，结束循环和return：结束方法的区别
方法名：注意规范
参数列表：参数类型，参数名
异常抛出
方法的调用
静态方法：
非静态方法
public class Demo03 {
public static void main(String[] args) {
//static静态方法在类加载时就存在，可以直接调用
int add = Demo03.add(1,2);
System.out.println(add);
//非静态方法要在实例化之后才存在
Demo03 demo03 = new Demo03();
int reduce = demo03.reduce(3,1);
System.out.println(reduce);
}
public static int add(int a,int b){
return a+b;
}
public int reduce(int a,int b){
return a-b;
}
} 形参和实参
值传递和引用传递
public class Demo04 {
public static void main(String[] args) {
//值传递
int a = 1;
System.out.println(a);// 1
Demo04.change(a);
System.out.println(a);// 1
}
//返回值为空，
public static void change(int a){
a = 10;
}
} //引用传递：对象
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
Demo05.change(person);
System.out.println(person.name);//zhenlu
}
public static void change(Person person){
person.name = "zhenlu";
}
}
class Person{
String name;
}
对象的创建分析
使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
1.必须和类的名字相同
2.必须没有返回类型，也不能写void
public class Person {
//一个类即使什么也不写，它也会存在一个方法
String name;
//实例化初始值
//使用new关键字，本质是在调用构造器
public Person(){
this.name = "zhenlu";
}
//有参构造：一旦定义了有参构造，无参构造就必须显示定义
public Person(String name){
this.name = name;
}
}
面向对象三大特性
封装
程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住：属性私有，get/set
意义：1.提高程序的安全性，保护数据。2.隐藏代码的实现细节。3.统一接口。4.系统可维护增加了。
继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
Java中类只有单继承，没有多继承。一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子。
object类：在Java中，所有类都间接或直接的继承Object。
super：注意点
1、super调用父类的构造方法，必须在构造方法的第一个
2、super必须只能出现在子类的方法或者构造方法中！
3、super和this不能同时调用构造方法！
VS this：
代表的对象不同：this代表本身调用者这个对象，super代表父类对象的应用
前提：this没有继承也可以使用，super只能在继承条件下才能使用
构造方法：this()本类构造，super父类的构造
//子类
//子类继承了父类，就会拥有父类的全部方法
//ctrl+H,可以查看继承关系
public class Student extends Person {
public Student(){
//隐藏代码：调用 了父类的无参构造
super();
System.out.println("Student无参执行了");
}
private String name = "adad";
public void print(){
System.out.println("Student");
}
public void test(String name){
System.out.println(name);//zhen
System.out.println(this.name);//adad
System.out.println(super.name);//zhenlu
}
public void test1(){
print();//Student
this.print();//Student
super.print();//Person
}
} //父类
//在Java中，所有类都间接或直接的继承Object
public class Person {
public Person(){
System.out.println("Person无参执行了");
}
protected String name = "zhenlu";
//私有的东西无法被继承
public void print(){
System.out.println("Person");
}
} 方法重写
静态方法
//重写都是方法的重写，和属性无关
public class B {
public static void test(){
System.out.println("B=>test()");
}
} public class A extends B{
public static void test() {
System.out.println("A=>test()");
}
} public class Application {
public static void main(String[] args) {
//方法的调用只和左边，定义的数据类型有关
A a = new A();
a.test();//A
//父类的引用指向子类
B b = new A();
b.test();//B
}
}
非静态方法
public class B {
public void test(){
System.out.println("B=>test()");
}
}
public class A extends B{
@Override //注解 重写
public void test() {
System.out.println("A=>test()");
}
}
public class Application {
//静态方法：方法的调用只和左边，定义的数据类型有关
//非静态方法：重写
public static void main(String[] args) {
A a = new A();
a.test();//A
//父类的引用指向子类
B b = new A();
b.test();//A
}
}
重写：需要有继承关系，子类重写父类的方法！
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大但不能缩小： public>Protected>Default>private
4、抛出的异常：范围，可以被缩小，但不能扩大
为什么需要重写？
1、父类的功能，子类不一定需要，或者不一定满足！
多态
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
多态存在的条件
1、有继承关系
2、子类重写父类方法
3、父类引用指向子类对象
public class Student extends Person{
@Override
public void run() {
System.out.println("Student run");
}
public void eat(){
System.out.println("eat");
}
}
public class Person {
public void run(){
System.out.println("run");
}
}
public static void main(String[] args) {
// 一个对象的实际类型是确定的
// 可以指向的引用类型就不确定了：父类的引用指向子类
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
// 对象能执行哪些方法，主要看对象左边的类型，和右边关系不打
// s2.eat（）；Person中没有eat方法所以不能执行
// 子类重写了父类的方法，执行子类的方法
s1.eat();
}
多态注意事项：
1、多态是方法的多态，属性没有多态
2、父类和子类，有联系 类型转换异常！
static关键字//static方法，变量
public class Student {
private static int age;//静态变量
private double score;//非静态变量
public void run(){
go();//非静态方法可以调用静态方法
}
public static void go(){
//静态方法不能调用非静态方法
}
public static void main(String[] args) {
Student.go();//直接使用
Student s1 = new Student();
System.out.println(Student.age);
System.out.println(s1.age);
System.out.println(s1.score);
}
}
//静态代码块
public class Person {
//第二个执行
{
System.out.println("匿名代码块");
}
//第一个执行,只执行一次
static {
System.out.println("静态代码块");
}
//第三个执行
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person = new Person();
System.out.println("==============");
Person person1 = new Person();
}
}
//静态导入包
import static java.lang.Math.PI;
import static java.lang.Math.random;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
抽象类和接口
抽象类
abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；修饰类，就是抽象类。
抽象类中可以没有抽象方法，但有抽象方法的类一定是抽象类。
抽象类不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
//抽象类
public abstract class Action {
//约束，有人帮我们实现
//抽象方法，没有实现
public abstract void doSth();
}
//抽象类的所有方法，继承了她的
public class A extends Action{
@Override
public void doSth() {
}
}
接口 接口只有规范！接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想。如果你是汽车，则必须能跑。
接口的本质是契约，就像人间的法律一样，制定好后大家都遵守。
声明接口的关键字是interface。
public interface UserService {
//接口中的所有定义其实都是抽象的，默认public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeService {
void timer();
}
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
//接口可以多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
内部类
成员内部类
public class Outer {
private int id;
public void out(){
System.out.println("外部类方法");
}
public class Inner{
public void in(){
System.out.println("内部类方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
public class Application {
public static void main(String[] args) {
//new
Outer outer = new Outer();
//通过外部类来实例化内部类；
Outer.Inner inner = outer.new Inner();
inner.in();
}
}
静态内部类
public class Outer {
private int id;
public void out(){
System.out.println("外部类方法");
}
public static class Inner{
public void in(){
System.out.println("内部类方法");
}
//静态内部类不能访问外部类的私有属性
public void getID(){
// System.out.println(id);
}
}
}
局部内部类
public class Outer {
public void method(){
class Inner{
public void in(){
}
}
}
}
匿名内部类
public class Test {
public static void main(String[] args) {
//没有名字初始化类,不用将实例保存到变量中
new Apple().eat();
}
}
class Apple{
public void eat(){
System.out.println("!");
}
}
