Java学习之路0720（六）（类与对象、封装、继承）

类、对象

对象的定义：用来描述一个事物的实例化，拥有属性和方法

对象的特征：属性和方法

属性：对象具有的各项特征，每个对象的每个属性都拥有特定值

方法：对象执行的操作

类的定义：拥有一组相同属性和方法的一组对象的集合。抽象化概念，仅是模板。

类与对象的联系：类是对象的抽象化，对象是类的实例化。

包的命名规范：Java包的命名规则是全部使用小写字母，在Java中定义包名时通常使用创建者的Internet域名的反序。

例如：域名为www.baidu.com,包名为packet com.baidu;

属性的命名：访问修饰符 类型 变量名称

方法的命名：访问修饰符 返回类型值 方法名称（参数列表）{//方法体}

方法编写时易错点：

方法只能返回一个值，

public int person(){
int i=0;
int j=1;
return i,j;
}

方法之间不能嵌套，

public int person(){
public int son(){
int i=0;
return 0;
}
return 0;
}

不能在方法外面直接写逻辑语句

public class Person(){
if(){
System.out.println("异常");
}
public void work(){
System.out.println("打球")
}
}

类的声明：方法修饰符 class 类名{//类体}

注意：类名首字母大写，属性、方法首字母必须小写

break的使用：在while/for/do…while中跳出循环体，在switch…case中跳出选择

return的使用：填出方法，给出结果

Java中的构造方法：

Java中会带有一个默认的无参构造器，当创建任何一种构造器后都会将默认构造器删除

引用数据类型方法传递的是复制的地址，简单数据类型方法传递是复制的数据

public class StudentTest {
public static void main(String[] args) {
Student zhangsan=new Student();
zhangsan.student(18,"zhangsan","Mr.Li");
System.out.println(zhangsan.name);
Student lisi=new Student();
lisi=zhangsan;//将存放zhangsan.name的地址复制一份给lisi
if(lisi.name==zhangsan.name){//lisi.name的地址就和zhangsan.name的地址指向同一个地址
System.out.println("1");
}
//System.out.println(lisi.name);
lisi.name="lisi";
System.out.println(zhangsan.name);
int j=0;
int i=j;//将j中的数据复制一份给i，当中的数据改变时，j中数据不受影响
i++;
System.out.println("j="+j);
System.out.println("i="+i);
//student1.student();
}
}

在方法中可变参数必须是方法定义中的最后一个参数

public class Test {
public static void main(String[] args) {
int book1;
readBook("西游记","红楼梦");
}
public static void readBook(String... book1){
}
}

public ststic void redbook(int ...i,String s){
}//错误语法

变量声明的位置决定变量的作用域

变量作用域确定可在程序中按变量名访问该变量的区域

全局变量与局部变量

全局变量也叫成员变量，是在类中定义的变量作用域为整个类，可以不用赋初始值，Java中为成员变量赋初值

局部变量是在成员方法中定义的变量，只能在该方法中使用，且同一方法中的变量名不能一样，否则不能区别，局部变量必须赋初始值

public class Person {
public int age;
public int weight;
public int hight;
public int time;
public void showInfo(){
System.out.println(time+" "+age+" "+weight+" "+hight);
}
public int setAge(int age){
int age1=0;
age1=age;
System.out.println(age1);
return 0;
}
public int setWeight(int weight){
int weight1=0;
weight1=weight;
System.out.println(weight1);
return 0;
}
public int setHight(int hight){
int hight1=0;
hight1=hight;
System.out.println(hight1);
return 0;
}
}

public class PersonTest {
public static void main(String[] args) {
Person zhangsan=new Person();
Person lisi=new Person();
zhangsan.age=18;
zhangsan.hight=60;
zhangsan.hight=177;
zhangsan.time=2015;
zhangsan.showInfo();
zhangsan.setAge(19);
zhangsan.setHight(179);
zhangsan.setWeight(70);
}
}

封装:

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的好处：1、隐藏类的实现细节；2、方便加入控制语句；3只能通过方法访问数据；4、方便与修改实现

继承

继承后的初始化顺序：先父类，接着属性，再构造器，再子类，后属性，最后构造器。

方法重写：也叫方法覆盖，在继承关系的子类中，重写的方法名，参数，返回值必须与父类相同，私有方法不能继承因而也无法重写。

方法重载：在同一类中允许同时存在一个以上方法，只要这些方法的参数个数或类型不同即可。

父类：
public class thisFather {
public thisFather(){
this.work();
System.out.println("这是父类的无参构造");
}
public thisFather(int i){
int age=i;
System.out.println("这是父类的有参构造"+i);
}
public void work(){
System.out.println("工作");
}
}
子类：
public class thisSon extends thisFather{
public thisSon(){
System.out.println("这是子类的无参构造");
}
public thisSon(int i){
//this();
this.study();
int age=i;
System.out.println("这是子类的有参构造"+i);
}
public void study(){
System.out.println("学习");
}
}

测试：
public class thisTest {
public static void main(String[] args) {
thisSon son=new thisSon();
thisSon boy=new thisSon(5);
}
}

封装类:将简单数据类型封装成引用型数据类型

public class Test {
public static void main(String[] args) {
Integer h=new Integer(10);
int i=10;
int j=0;
Integer g=new Integer(10);
System.out.println(h==g);//引用型数据类型，地址不同数据值相同,输出为false
System.out.println(h.equals(g));//true
System.out.println(i==j);//false
System.out.println(h==i);//true,引用型数据类型和简单型数据类型比较时会自动拆包为简单型数据类型
j=new Integer(10);//自动拆包
g=10;             //自动装包
System.out.println(h==g);//false
System.out.println(h.equals(g));//true
System.out.println(i==j);//true
System.out.println(h==j);//true
}
}

this 关键字

调用该方法的对象，实例化类中的方法

1、this.属性 该方法的属性

2、this.方法 该类中对象的方法

3、this（） 必须放在第一行，调用本类中的另一个构造方法（this（类型 参数）调用有参构造，this（）调用无参构造）；

/*父类
public class thisFather {
public thisFather(){
this.work();
System.out.println("这是父类的无参构造");
}
public thisFather(int i){
int age=i;
System.out.println("这是父类的有参构造"+i);
}
public void work(){
System.out.println("父类的方法--工作");
}
}

/*
* 子类
*/
public class thisSon extends thisFather{
private int age=10;
public thisSon(){
System.out.println("这是子类的无参构造");
}
public thisSon(int i){
this();          //调用本类的无参构造
this.study();    //调用本类的方法
this.age=i;      //调用本类的属性
System.out.println("这是子类的有参构造"+age);
}
public void study(){
System.out.println("子类的方法--学习");
}
}

/*
* test类
*/
public class thisTest {
public static void main(String[] args) {
thisSon son=new thisSon();
thisSon boy=new thisSon(5);
}
}

运行结果：

父类的方法–工作

这是父类的无参构造

这是子类的无参构造

父类的方法–工作

这是父类的无参构造

这是子类的无参构造

子类的方法–学习

这是子类的有参构造5

super关键字

用于子类访问，引用父类中被屏蔽的成员变量或成员方法，

this用于子类访问本类中成员变量或方法，构造方法的第一行会默认添加super();调用父类的构造方法，且不能和this()一起使用。

第一、在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。

第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。

第三、当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（但方法体可以不同），此时，用“super.方法名(参数列表)”的方式访问父类的方法。

package jie0725;

public class Parent {

public int age;
public String name;
public void dinner (){
System.out.println("父类的方法--吃饭");
}
public Parent(){
System.out.println("父类的无参构造");
}
public Parent(int j){
int i=j;
System.out.println("父类的无参构造"+i);
}
}

public class Son extends Parent{
private  int i;
private int age;
public void study(){
System.out.println("子类的方法--学习");
}
public Son(){

System.out.println("子类的无参构造");
}
public Son(int j){
super(j);
super.dinner();

int i=j;
System.out.println("子类的有参构造"+i);
}
}

public class Test {
public static void main(String[] args) {
Son s=new Son();
Son s1=new Son(5);
}
}

运行结果：

父类的无参构造

子类的无参构造

父类的无参构造5

父类的方法–吃饭

子类的有参构造5

详见;/article/4705831.html