JAVA技术及应用（第二版）（赵锐，李卫华）学习总结

第二章

2.1.1类与对象的概念

有共同特点的软件对象可以抽象成为一类，类中定义各对象共有的变量和方法，成为原型。由原型可以定义一个个具体的对象，成为实例。

由类产生实例的过程充分体现了类的可复用性

2.21类与对象的关系

对象是类的实例，类是公有特性的对象的抽象。

2.2类的定义

class Bike{
public boolean ispublish=ture;
piblic float Charge(float h){
return 1*h;
} 
}

2.2.1类声明部分

modifiers部分	修饰符部分，可设置为abstract，final，public
1.abstract	抽象类，不能直接实例化为对象，只能被子类继承抽象方法由子类重写
2.final	最终类，不能有子类，不能被继承，不能被重写，确保唯一性
3.public	公用类，可以被所属包之外的其他类与对象调用
4.省略“友好的”	只能在当前包使用

2.2.3成员变量

类变量：在类中只出现一次，只分配一次内存，可被公用
实例变量：每创建一次实例，都为实例变量分配一次内存，不可被公用

accessSpecifier访问限制符

限制类	同类	同包	子类	不同包
public 公共变量	Y	Y	Y	Y
protected保护变量	Y	Y	Y	N
省略（friendly）	Y	Y	N	N
private私有变量	Y	N	N	N

static关键字：表明这个变量是类变量而不是实例变量，可以被共用
final关键字：表明这个变量是一个常数

2.2.4方法

class Myclass{
int op1,op2;
int myMethod(int op3,int op4){//方法声明
int op5;//方法内部局部变量
op5=op3*op4;
return op5;
}
}

2.2.5构造方法

格式

• 类的第一个字母大写
• 对象全部为小写

构造方法是在new一个对象时被自动调用的

构造方法有专门的用途，用于建立本类的一个新对象，并且对新对象进行 初始化

class Rect{
protected float widrh,height;//保护权限的成员变量
public float area;//公有权限的成员变量
public Rect(float w, float h){//构造方法对成员变量进行初始化
width =w;
height =h;
area=getArea(w,h);
}
public float getArea (float w, float h){//求面积由构造方法调用
float a;
a=w*h;
return a;
}
}

class MyRect{
public static void main(String[] args) {
Rect rect =new Rect(4.0f,6.0f)
//建立类Rect 的实例rect,用4.0,6.0初始化w,h
}
}

2.2.6方法重载

用同一个方名表示一个类中不同行为的几个方法，但是参数不能一致

class point{
point(int x,int y){//构造方法
.......
}
double distance(int x,int y){
.......
}
double diatance(point p){//方法重载
..........
}
}

2.3.1对象的创建

Myclass objectA=new Myclass();

2.4.1合成与继承

2.4.2

继承：JAVA的继承是单继承性，只允许继承一个超类

• 若子类方法重写了其超类的某个方法，可以用super来调用这个被重写方法

方法的重写：在类的继承过程中，子类经常会重写超类的方法，因为他想改进功能

class Myclass{//定义超类
    boolean op1;
    int text;
    void Myethod(){
        op1=true;
        text=10;
    }
}
class Mysub extends Myclass{//子类
    boolean op1;//定义与超类同名的成员变量
    int text;
    void Mymethod(){
        op1=false;
        text=100;
        super.Myethod();//调用超类的成员方法
        System.out.println(text+""+op1);
        System.out.println(super.text+""+super.op1);//输出超类op1;
    }

}
public class Mysubshow {
    public static void main(String[] args) {
        Mysub sub=new Mysub();
        sub.Mymethod();

    }
}

2.6.1抽象类

含抽象方法的类一定要声明为抽象类，因为这种类不能实例化，只能继承 ，目的是让子类对它进行改进

2.6.2接口

//接口声明
interface Deckaration{
interface Body
}

(1)public访问限制表明改接口可以被任何宝的各类使用
(2)extends可以包含多个接口名，用 ，隔开，继承接口的常量和方法

public interface Myable extends My1,My2{
..........
}

3.实现接口
接口由类来实现，在类声明中若有implements关键字，其后会有若干个在该类中实现的接口名

2.7.1抽象类与多态

书本P61

2.7.2接口与多态

interface Bike{//2.7.2接口与多态
    public  final  boolean ispublic=true;
    public  float charge(float h);
    public String getBikeName();

}
class Mobike implements Bike{
    public float charge(float h){
        return 2*h;
    }

public String getBikeName(){
        return  "摩拜单车";
}
}


 class Ofo implements Bike{
    public  float charge(float h){
        return 1*h;}
        public String getBikeName(){
            return "小黄车";
        }
    }

public class UseBike {
    public static void main(String[] args) {
        Bike[] b=new Bike[2];
        b[0] =new Mobike();
        b[1] =new Ofo();

        for(  Bike bik:b)
        {
            System.out.println(bik.getBikeName());
            System.out.println(bik.charge(4));
        }
        }

        }

2.8泛型

用某个未指定的类型T取代整形类型，实际使用时再代入具体类型，那么就可以处理多种类型的对象

interface Room<T>{
    void find(T t);
}

class RoomImp1<T> implements Room<T>{//未指定具体的泛型类型
    public void find(T t){
        System.out.println("你预定的是"+t);
    }
}
class RoomImp2 implements Room<Integer>{//指定具体的泛型类型
    public void find(Integer t){
        System.out.println("您的房间号是"+t);
    }
}
public class TestRoomImp1 {
    public static void main(String[] args) {
        RoomImp1<String> r=new RoomImp1<>();//创建对象时指定具体的类型
        r.find("宝格丽酒店");
        RoomImp2 r2=new RoomImp2();
        r2.find(603);
    }
}

2.9枚举

枚举类型是一个类型的域中包含一组设定好的常数

enum Season{
    SPRING,SUMMER,AUTUMN,WINTER
}


public class Myenum {

    public static void main(String[] args) {
        Season s1=Season.WINTER;
        System.out.println(s1);
        Season s2=Season.SPRING;
        System.out.println(s2);
    }

}

第三章

lambda介绍

lambda使JAVA能像C#和C++一样进行简单“函数式编程”
习题三
1.什么是lambda表达式
lambda表达式是基于数学中λ演算得名，本质上就是一个没有方法体的匿名方法
2.什么是函数式接口
函数式接口是只包含有一个抽象方法的接口，又被称为单例抽象类接口

该接口中只包含有一个抽象方法run（），所以是一个典型的函数式接口
public interface Runnable{
void run();
}

3.举例说明lambda表达式和函数接口是如何关联的
对照参考书本P74-75【例3.1】和【例3.2】

interface myInter{//函数式接口
    double computer(double x,double y);//唯一抽象方法
}
interface  Inter<T>{//泛型函数式接口
    T computer(T x,T y);
}
}
public class _lambda {
    public static void main(String[] args) {
      myInter add=(m,n)->m+n;//lambda表达式赋值为改接口的一个引用
        System.out.println(add.computer(90,20));
        Inter<Integer>  add1=(n,m)->n+m;//指定lambda表达式中参数为int类型
        System.out.println(add1.computer(20,90));
    }

}

4.什么是方法引用
在某些情况下lambda表达式里面可能仅仅只有一个方法调用，在这种情况下，可以不用lambda表达式，而直接通过方法名称来引用方法
5.举例说明方法引用和表达式有何关联

interface  _myInter{//构造方法的方法引用
    myTest test(int op1,int op2);
}
class myTest{
    private int n,m;
    myTest(int op1,int op2){
        m=op1;n=op2;
    }
    int getM(){return  m;}
    int gerN(){return  n;}
}



 class methodReferTest4 {
     public static void main(String[] args) {
         _myInter m1=myTest::new;
         myTest mt1=m1.test(20,6);
         System.out.println(mt1.gerN()+"\n"+mt1.getM());
     }
}

静态方法的方法引用

interface myInter{//创建接口
    void test(int x,int y);
}
class myCompare{
    static void compare(int m,int n){
        if(m<n) System.out.println(m+"<"+n);
        if(m>n) System.out.println(m+">"+n);
        if(m==n) System.out.println(m+"="+n);
    }
}


public class mythodReferTest1 {

        static   void compTest(myInter p,int op1,int op2){
        //设置一个方法给静态方法引用myInter p接受myCompare::compare，
       //通过p.text给引用的compare方法传数据
            p.test(op1,op2);
        }

    public static void main(String[] args) {
        compTest(myCompare::compare,6,6);
    }


}