尚硅谷java基础学习笔记之面向对象

Posted 少年风华正茂

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了尚硅谷java基础学习笔记之面向对象相关的知识,希望对你有一定的参考价值。

一、概论

1.面向对象的编程关注于类的设计!

1)一个项目或工程,不管多庞大,一定是有一个一个的类构成的。
2)类是抽象的,好比是制造汽车的图纸。

     而具体的一辆一辆的车,是根据图纸制造的,实际上就是类的实例化


2.完成一个项目(或功能)的思路
1)所要完成的功能对应的类的对象是否存在。
2)若存在,则通过对象直接调用对应的类中的属性或方法即可

3)若不存在,需要创建类的对象。甚至说,类都不存在,就需要设计类。


3.面向对象编程的三条主线:
1)类及类的构成成分:属性  方法 构造器  代码块 内部类
2)面向对象编程的特征:封装性  继承性 多态性  (抽象性)

3)其它的关键字:this super package import static final abstract interface ...


二(1)面向对象

①类及对象

1.关于类的设计

2.类的组成成分:
   1) 属性(成员变量,Field)
   2)方法(成员方法,函数,Method)

2.1属性:
     *   成员变量 vs 局部变量
 *   相同点:1.遵循变量声明的格式: 数据类型 变量名 = 初始化值
 *     2.都有作用域
 *   不同点:1.声明的位置的不同 :成员变量:声明在类里,方法外
 *      局部变量:声明在方法内,方法的形参部分,代码块内
 *         2.成员变量的修饰符有四个:public private protected 缺省
 *           局部变量没有修饰符,与所在的方法修饰符相同。
 *         3.初始化值:一定会有初始化值。
 *         成员变量:如果在声明的时候,不显式的赋值,那么不同数据类型会有不同的默认初始化值。
 *            byte short int long ==>0
 *            float double ==>0.0
 *            char ==>空格
 *            boolean ==>false 
 *            引用类型变量==>null
 *          局部变量:一定要显式的赋值。(局部变量没有默认初始化值)
 *         4.二者在内存中存放的位置不同:成员变量存在于堆空间中;局部变量:栈空间中
 *         
 * 总结:关于变量的分类:1)按照数据类型的不同:基本数据类型(8种)  & 引用数据类型
 *   2)按照声明的位置的不同:成员变量 & 局部变量

2.2 方法:提供某种功能的实现
 *    1)实例:public void eat()//方法体
 *           public String getName()
 *           public void setName(String n)
 *      格式:权限修饰符 返回值类型(void:无返回值/具体的返回值) 方法名(形参)
 *      
 *    2)关于返回值类型:void:表明此方法不需要返回值
 *       有返回值的方法:在方法的最后一定有return + 返回值类型对应的变量
 *       记忆:void 与return不可以同时出现一个方法内。像一对“冤家”。
 * 
 *  3)方法内可以调用本类的其他方法或属性,但是不能在方法内再定义方法!

3.面向对象编程的思想的落地法则一:
1)设计并创建类及类的成分
2)实例化类的对象
3)通过“对象.属性”或"对象.方法"的形式完成某项功能

4.类的初始化的内存解析
4.1  内存划分的结构:
      栈(stack):局部变量 、对象的引用名、数组的引用名
      堆(heap):new 出来的“东西”(如:对象的实体,数组的实体),含成员变量
      方法区:含字符串常量
      静态域:声明为static的变量

4.2 理解的基础上,学会基本的创建的类的对象在内存中的运行。



②方法的重载(overload)

* 要求:1.同一个类中 2.方法名必须相同 3.方法的参数列表不同(①参数的个数不同②参数类型不同)
 * 补充:方法的重载与方法的返回值类型没有关系!

//如下的四个方法构成重载
//定义两个int型变量的和
public int getSum(int i,int j)
return i + j;

//定义三个int型变量的和
public int getSum(int i,int j,int k)
return i + j + k;

//定义两个double型数据的和
public double getSum(double d1,double d2)
return d1 + d2;



//定义三个double型数组的和
public void getSum(double d1,double d2,double d3)
System.out.println(d1 + d2 + d3);

//不能与如上的几个方法构成重载
// public int getSum1(int i,int j,int k)
// return i + j + k;
//
// public void getSum(int i,int j,int k)
// System.out.println(i + j + k);
//

//以下的两个方法构成重载。
public void method1(int i,String str)


public void method1(String str1,int j)





③可变个数的形参的方法

 * 1.格式:对于方法的形参: 数据类型 ... 形参名
 * 2.可变个数的形参的方法与同名的方法之间构成重载
 * 3.可变个数的形参在调用时,个数从0开始,到无穷多个都可以。
 * 4.使用可变多个形参的方法与方法的形参使用数组是一致的。
 * 5.若方法中存在可变个数的形参,那么一定要声明在方法形参的最后。
 * 6.在一个方法中,最多声明一个可变个数的形参。

//如下四个方法构成重载
//在类中一旦定义了重载的可变个数的形参的方法以后,如下的两个方法可以省略
// public void sayHello()
// System.out.println("hello world!");
//
// public void sayHello(String str1)
// System.out.println("hello " + str1);
//
//可变个数的形参的方法
public void sayHello(String ... args)
for(int i = 0;i < args.length;i++)
System.out.println(args[i] + "$");

//System.out.println("=====");


public void sayHello(int i,String ... args)
//public void sayHello(String ... args,int i)
System.out.println(i);

for(int j = 0;j < args.length;j++)
System.out.println(args[j] + "$");



public void sayHello1(String[] args)
for(int i = 0;i < args.length;i++)
System.out.println(args[i]);





④java中的传递机制

* 方法的参数传递(重点、难点)
 * 1.形参:方法声明时,方法小括号内的参数
 *   实参:调用方法时,实际传入的参数的值
 *   
 * 2.规则:java中的参数传递机制:值传递机制
 *   1)形参是基本数据类型的:将实参的值传递给形参的基本数据类型的变量
 *   2)形参是引用数据类型的:将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)传递给形参的引用类型变量。

【典型例题1】


public static void main(String[] args)
TestArgsTransfer tt = new TestArgsTransfer();

int i = 10;
int j = 5;
System.out.println("i:" + i + " j:" + j);//i : 10  j : 5

// //交换变量i与j的值
// int temp = i;
// i = j;
// j = temp;
tt.swap(i, j);//将i的值传递给m,j的值传递给n


System.out.println("i:" + i + " j:" + j);//i : 10  j : 5


//定义一个方法,交换两个变量的值
public void swap(int m,int n)
int temp = m;
m = n;
n = temp;
System.out.println("m:" + m + " n:" + n);




【典型例题2】
public class TestArgsTransfer1
public static void main(String[] args)
TestArgsTransfer1 tt = new TestArgsTransfer1();
DataSwap ds = new DataSwap();

System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);

tt.swap(ds);
System.out.println(ds);

System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);


//交换元素的值
public void swap(DataSwap d)
int temp = d.i;
d.i = d.j;
d.j = temp;
System.out.println(d);//打印引用变量d的值




class DataSwap
int i = 10;
int j = 5;



⑤面向对象的特征一:封装与隐藏

 * 问题:当创建了类的对象以后,如果直接通过"对象.属性"的方式对相应的对象属性赋值的话,可能会出现不满足实际
 * 情况的意外,我们考虑不让对象来直接作用属性,而是通过"对象.方法"的形式,来控制对象对属性的访问。实际
 * 情况中,对属性的要求就可以通过方法来体现。
 * 
二、面向对象思想的落地法则二:
(封装性的思想)①将类的属性私有化,②提供公共的方法(setter & getter)来实现调用。


三、四种权限修饰符
1.权限从大到小为:public   protected   缺省   private  
2.四种权限都可以用来修饰属性、方法、构造器
3.修饰类的话:public 缺省





⑥构造器

 * 一、类的第三个成员:构造器(constructor 构造方法)   construction  CCB  ICBC   oop
 * constructor:建造者 
 * 构造器的作用:①创建对象 ②给创建的对象的属性赋值
 * 
 * 1.设计类时,若不显式声明类的构造器的话,程序会默认提供一个空参的构造器.
 * 2.一旦显式的定义类的构造器,那么默认的构造器就不再提供。
 * 3.如何声明类的构造器。格式:权限修饰符  类名(形参)
 * 4.类的多个构造器之间构成重载
 * 二、类对象的属性赋值的先后顺序:①属性的默认初始化 ②属性的显式初始化③通过构造器给属性初始化
 *  ④通过"对象.方法"的方式给属性赋值



⑦this关键字

1.使用在类中,可以用来修饰属性、方法、构造器
2.表示当前对象或者是当前正在创建的对象
3.当形参与成员变量重名时,如果在方法内部需要使用成员变量,必须添加this来表明该变量是类成员
4.在任意方法内,如果使用当前类的成员变量或成员方法可以在其前面添加this,增强程序的阅读性
5.在构造器中使用“this(形参列表)”显式的调用本类中重载的其它的构造器
   >5.1 要求“this(形参列表)”要声明在构造器的首行!
   >5.2 类中若存在n个构造器,那么最多有n-1构造器中使用了this。



⑧package/import

/*
 * package:声明源文件所在的包,写在程序的第一行。
 *   每“.”一次,表示一层文件目录。
 *   包名都要小写。
 *   
 * import:
 * 1)显式导入指定包下的类或接口
 * 2)写在包的声明和源文件之间
 * 3)如果需要引入多个类或接口,那么就并列写出
 * 4)如果导入的类是java.lang包下的,如:System String Math等,就不需要显式的声明。
 * 5)理解.*的概念。比如java.util.*;
 * 6)如何处理同名类的导入。如:在util包和sql包下同时存在Date类。
 * 7)import static 表示导入指定类的static的属性或方法
 * 8)导入java.lang.*只能导入lang包下的所有类或接口,不能导入lang的子包下的类或接口
 */
//import java.util.Scanner;
//import java.util.Date;
//import java.util.List;
//import java.util.ArrayList;
import java.lang.reflect.Field;
import java.util.*;
import static java.lang.System.*;
public class TestPackageImport
public static void main(String[] args)
out.println("helloworld");
Scanner s = new Scanner(System.in);
s.next();

Date d = new Date();
List list = new ArrayList();

java.sql.Date d1 = new java.sql.Date(522535114234L);

Field f = null;




二(2)面向对象

①面向对象的特征二:继承性

 *1.通过"class A extends B"类实现类的继承。
 *   子类:A  父类(或基类 SuperClass):B
 *   
 * 2.子类继承父类以后,父类中声明的属性、方法,子类就可以获取到。
 *    明确:当父类中有私有的属性或方法时,子类同样可以获取得到,只是由于封装性的设计,使得子类不可以直接
 *        调用罢了。
 *   子类除了通过继承,获取父类的结构之外,还可以定义自己的特有的成分。
 *   
 *   extends:子类是对父类功能的“扩展”,明确子类不是父类的子集。
 *   
 * 3.java中类的继承性只支持单继承:一个类只能继承一个父类。反之,一个父类可以有多个子类。

 * 4.子父类是相对的概念。


方法的重写(override orverwrite)   vs   重载(overload)
方法的重载与重写的区别?
重载:“两同一不同”:同一个类,同一个方法名,不同的参数列表。 注:方法的重载与方法的返回值无关!
         >构造器是可以重载的
重写:(前提:在继承的基础之上,子类在获取了父类的结构以后,可以对父类中同名的方法进行“重构”)
        方法的返回值,方法名,形参列表形同;权限修饰符不小于父类的同名方法;子类方法的异常类型不大于父类的;
        两个方法要同为static或同为非static。


②关键字super

1.super,相较于关键字this,可以修饰属性、方法、构造器


2.super修饰属性、方法:在子类的方法、构造器中,通过super.属性或者super.方法的形式,显式的调用父类的指定
   属性或方法。尤其是,当子类与父类有同名的属性、或方法时,调用父类中的结构的话,一定要用“super.”


3.通过“super(形参列表)”,显式的在子类的构造器中,调用父类指定的构造器!
>任何一个类(除Object类)的构造器的首行,要么显式的调用本类中重载的其它的构造器“this(形参列表)”或显式的调用父类中
指定的构造器“super(形参列表)”,要么默认的调用父类空参的构造器"super()"
>建议在设计类时,提供一个空参的构造器!


③子类对象实例化的全过程

public class TestDog
public static void main(String[] args)
Dog d = new Dog();
d.setAge(10);
d.setName("小明");
d.setHostName("花花");


System.out.println("name:" + d.getName() + " age:" + d.getAge()
+ "hostName:" + d.getHostName());

System.out.println(d.toString());




// 生物
class Creator
private int age;


public int getAge()
return age;



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



public Creator()
super();
System.out.println("this is Creator's constructor");






// 动物类
class Animal extends Creator
private String name;


public String getName()
return name;



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



public Animal()
super();
System.out.println("this is Animal's constructor");






// 狗
class Dog extends Animal
private String hostName;


public String getHostName()
return hostName;



public void setHostName(String hostName)
this.hostName = hostName;



public Dog()
super();
System.out.println("this is Dog's constructor");








④面向对象的特征三:多态性

1.多态性的表现:①方法的重载与重写   ②子类对象的多态性
2.使用的前提:①要有继承关系 ②要有方法的重写
3.格式:Person p = new Man();//向上转型
            // 虚拟方法调用:通过父类的引用指向子类的对象实体,当调用方法时,实际执行的是子类重写父类的方法
   p1.eat();
   p1.walk();
  // p1.entertainment();
4.>编译时,认为p是Person类型的,故只能执行Person里才有的结构,即Man里特有的结构不能够调用
  >子类对象的多态性,并不使用于属性。
5.关于向下转型:
  ①向下转型,使用强转符:()
   ②为了保证不报ClassCastException,最好在向下转型前,进行判断: instanceof
// 若a是A类的实例,那么a也一定是A类的父类的实例。
if (p1 instanceof Woman)
System.out.println("hello!");
Woman w1 = (Woman) p1;
w1.shopping();

if (p1 instanceof Man)
Man m1 = (Man) p1;
m1.entertainment();




⑤Object类

1.java.lang.Object 类,是所有类的根父类!

2.Object类仅有一个空参的构造器  public Object()  

3.关于方法:
  ① equals(Object obj)

  public boolean equals(Object obj)
        return (this == obj);
   

// ==
// 1.基本数据类型:根据基本数据类型的值判断是否相等。相等返回true,反之返回false
// 注:两端数据类型可以不同,在不同的情况下,也可以返回true。
// 2.引用数据类型:比较引用类型变量的地址值是否相等。

//equals():
>①只能处理引用类型变量②在Object类,发现equals()仍然比较的两个引用变量的地址值是否相等
>像String 包装类 File类 Date类这些重写Object类的equals()方法,比较是两个对象的
//"实体内容"是否完全相同。
>若我们自定义一个类,希望比较两个对象的属性值都相同的情况下返回true的话,就需要重写Object类的
 equals(Object obj)方法

② toString()方法
当我们输出一个对象的引用时,会调用toString()方法。
1.public String toString()
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
   
当我们没有重写Object类的toString()方法时,打印的就是对象所在的类,以及对象实体在堆空间的位置
2.一般我们需要重写Object类的toString()方法,将此对象的各个属性值返回。
3.像String类、Date、File类、包装类都重写了toString()方法。



⑥包装类

基本数据类型由于不是类,不能够使用java类库里提供的大量的方法。所有在设计上,
我们让每一个基本数据类型都对应一个类,同时数据存储的范围还不变。此时相当于
基本数据类型就具有了类的特点。这些类即为包装类(wrapper 或封装类)


我们需要掌握的:
基本数据类型、包装类、String类之间的转换!



简易版:
1.基本数据类型与对应的包装类有自动装箱、自动拆箱
如:int i = 10;
      Integer i1 = i;//自动装箱
      int j = i1;//自动拆箱
2.基本数据类型、包装类---->String类:调用String类的重载的valueOf(Xxx xx);
  String类---->基本数据类型、包装类:调用相应的包装的parseXxx(String str);
  注意:String str = "123";
            int i = (int)str;是错误的转法。

以上是关于尚硅谷java基础学习笔记之面向对象的主要内容,如果未能解决你的问题,请参考以下文章

尚硅谷_Java零基础教程(常用类——String)-- 学习笔记

尚硅谷_Java零基础教程(常用类——ComparableComparator)-- 学习笔记

02尚硅谷宋红康Java视频笔记之语言概述

尚硅谷全套课件整理:Java前端大数据安卓面试题

尚硅谷_Java零基础教程(常用类——枚举类Enum)-- 学习笔记

juc并发编程学习笔记上(尚硅谷)