java学习笔记——韩顺平视频

Posted 2020-09-07

第0讲：开山篇

1.  Java se J2se        桌面

Java ee J2ee        网络

Java me J2me        手机

 

2.  SQL server   mysql   Oracle

 

3． 学习软件编程的注意事项

    1.高效愉快学习

    2.先建立一个整体框架然后细节

    3.用什么再学习什么

    4.先知道how，再知道why

    5.软件编程是一门“做中学”学科，做了才会

    6.适当囫囵吞枣

    7.琢磨别人怎么做，不是我认为这么做

 

第1讲  内容介绍.项目演示.原理剖析

1.  课程包括：java面向对象编程，java图形界面，java数据库编程，java文件i/o流，java网络编程，java的多线程

 

2.  Java历史：1990 sun 启动 绿色计划

     1992 创建 oak语言—> java

     1994 gosling 参加 硅谷大会 演示java功能 震惊世界

     1995 sun 正式发布java第一个版本，目前最新的是jdk7.0

 

3.  java开发工具：记事本，jcreator，jbuilder，netbean，eclipse

 

4.  jdk包括：jre（java运行环境）

java的工具：编译器javac.exe解释执行器java.exe

java的类库：3600多个，常用的150多个

 

5.  第一个程序：

//功能：显示“HelloWorld”

 

//public:表示类是公共的，一个文件中只有一个public类

//class:表示这个是一个类

//HelloWorld:类名（公共类的类名，必须和文件名一样）

public class HelloWorld

{

//一个主函数，程序的入口

public static void main (String args[])

{

     //执行语句

     System.out.println("helloWorld!");

}

}

 

6.  Java源程序（.java文件）——>java字节码文件（.class文件）——>由解释执行器（java.exe） 将字节码文件加载到java虚拟机（jvm）——>字节码文件（.class）就会在java虚拟机中执行

 

第2讲    变量.数据类型

1.       在java里面int占4个字节，long占8个字节

 

2.       Java基本数据类型：

整数 ：(byte一个字节 ：-128---127  int四个字节：-2147483648---[phone]   

short两个字节：-32768---+32767  long八个字节： )

小数（浮点）： float  double

布尔 ：boolean

字符：char（两个字节，可以存放汉字, char test1 =‘中‘;）                引申到 字符串（类）

 

3.       在java中对char进行运算的时候，直接是当做ASCII码对应的整数

 

4.       数据不能从高精度到低精度的转换  Byte<short<int<long<float<double

float a=3.4；是过不去的，在java中小数默认是double（双精度）的

应该写成是float a=3.4f；

不过可以强制转换：int a=(int)1.2; int b=(int)1.9

5.       int a=1;int b=a+1.2;  a先是往高精度转换，然后赋给b，就报错  改成int a=1;double b=a+1.2; 或者     int a=1;float b=a+1.2f; 就解决了

 

第4讲    流程控制

1.       switch case语句中，switch条件表达式的数据类型应该和后面case的类型一致

 

2.       switch case语句中，可用的数据类型主要是：byte short int char enum

 

3.       当型循环：for 和 while 循环

 

4.       直到型循环： do while循环

 

第5讲    类与对象

1.       面向对象编程-类与对象

类名首字母大写    

类里面的元素叫类的成员变量/属性

 

2.       类的定义

package 包名；

class 类名 extends 父类 implements

接口名

{

           成员变量；

           构造方法；

           成员方法；

}

 

3.       如何创建对象：

先声明再创建 Cat  cat1；cat1=new  Cat();

         一步到位        Cat  cat1 =new  Cat();

 

4.       引用传递类似于指针一样

 

第6讲    成员属性  成员方法

1.       对象总是在内存中的

 

2.       类成员方法：方法就是指某些行为，表示为函数

public 返回数据类型  方法名 （参数列表）

{

           语句；//方法（函数）主题

}

 

3.       类名首字母大写  方法名首字母小写           驼峰法（匈牙利法）     下划线法

 

4.        指针是存储地址的，不因为它的指向的数据的类型而改变大小。

 

第7讲 成员方法（函数）  构造方法

1.       类的成员方法声明

访问修饰符 数据类型 函数名（参数列表）；

2.       方法的参数列表是多个的，参数列表的数据类型是任意的

3.       在调用某个成员方法的时候给出的具体数值的个数和类型要相匹配

4.       方法可以没有返回值

5.       先设计类，然后根据类创建对象

6.       构造方法（构造函数）：完成对新对象的初始化：

方法名和类名相同

没有返回值

在创建一个类的新对象时，系统会自动调用该类的构造方法完成对新对象的初始化

一个类可以定义多个不同的构造方法

每个类都有一个默认的构造方法

 

第8讲 this 类变量

1.       this属于类的对象的而不是属于类的

2.       5this不能在类的外部使用，只能在类定义时候使用！

3.       可以用类名直接访问静态变量

 

第9讲 类方法 封装

1.类变量是该类的所有对象共享的对象,一改全改了

2.定义语法：访问修饰符 static 数据类型 变量名

3.     public class Demo9

{

static int i=1;

 

static

{

           System.out.println("zhixingyicile");

           i++;

}//会自动执行一次，也只有一次

 

public Demo9()

{

           System.out.println("ffffffff");

           i++;

}

 

public static void main(String args[])

{

           Demo9 t1=new Demo9();

           System.out.println(Demo9.i);

           Demo9 t2=new Demo9();

           System.out.println(i);

 

}

}

 

4.类方法（静态方法、静态函数）：属于所有对象实例的

5.Java中:类变量（static）原则上用类方法（static）去访问；类方法中不能访问非静态变量

，就是非类变量，但是普通的成员方法可以访问静态变量（类变量）

使用：类名.类方法名     对象名.类方法名

6.非类变量就是实例变量，属于每个对象自己的

7.Java面向对象编程的三（四）大特征：封装、继承、多态（、抽象）

8.抽象：把一类事物的共有的属性和行为提取出来，形成一个物理模板，此研究问题的方法就是抽象

9.封装：把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。

10.封装的访问控制修饰符

11.四种访问控制符：

公开级别：public

受保护级别：对子类和同一个包中的类公开

默认级别： 没有修饰符，向同一个包的类公开，子类不可以访问类中默认级别的元素的

私有级别：用private修饰，只有类本身才能访问

公开>受保护>默认>私有

12.

13.包的三大作用：区分相同名字的类  当类很多的时候可以很好的管理类 控制访问范围

14.包的打包命令：package  com.xiaoming  一般放在文件的开始的地方

15.引包命令：improt 包名

 

第10讲 访问修饰符  重载  覆盖

1.一个文家中如果只有public类，那么这个public类可以不用主函数

2. 不想被继承就设为protected

3.子类最多只能继承一个父类，Java里面不允许一个子类继承多个父类，C++却可以，如Java中一定要呢，就用接口吧

4.Java的所有类都是Object 的子类，继承层次数没有限制

5.JDK6.0里面有202个包，3777个类、接口、异常、枚举、注释和错误

6.在做开发的时候多使用JDK帮助文档

7.方法重载：类的同一种功能的多种实现方式，取决于调用者传递的参数

8.方法重载注意事项：

  方法名相同

  方法的参数类型，个数，顺序至少有一项不同

  方法的修饰符可以不同

  方法的返回类型可以不同

另外：

  只是返回类型不一样并不构成重载

  只是控制访问修饰符不一样不构成重载

 

第11讲  约瑟夫问题（丢手帕问题）

1.方法覆盖的：子类有一个方法和父类的某个方法名称、返回类型、参数一样

2.方法覆盖注意：

  子类的方法的返回类型、参数、方法名称要和父类的一样，否则编译出错

  子类方法不能缩小父类方法的访问权限，但是扩大是可以的

3.丢手帕问题：

 

第十二讲  多态

1.多态性:访问子类可以通过访问父类：

Animal cat =new Cat();

Animal dog =new Dog();

2.在使用多态的时候，如果有使用覆盖函数，那么被覆盖的方法（即是父类中的的那个相应的方法）是要存在的。

3. 多态：一个引用（类型）在不同情况下的多种状态，可使代码更加灵活

4.java允许父类的引用变量引用它子类的实例，是自动完成的

 

代码：

 

package com.agui;

public class Demo5 {

 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Dog2 ddd=new Dog2();
  ddd.cry();
  Cat2 ccc=new Cat2();
  ccc.cry();
  Animal2 an =new Cat2();
  an.cry();
  Master xxx=new Master();
  xxx.feed(new Dog2(),new Bone());
 }

}

//动物类
 class Animal2
{
 String name;
 int age;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }

 //叫
 public void cry()
 {
  System.out.println("buxiaodezenmejiao");

 }
 public void eat()
 {
 
  System.out.println("buzhidao chishenme");
 
 }
}
 
 class Master
 {
  //使用多态，方法就可以用一个了
 
 public void feed(Animal2 an,Food f)
  {
   an.eat();
   f.showName();
  }
 }

 
class Food
{
 String name;
 public void showName()
 {
 
 }
}

class Fish extends Food
{
 public void showName()
 {
  System.out.println("yurou");
 
 }
 
}
class Bone extends Food
{
 public void showName()
 {
  System.out.println("gutou");
 
 }
 
}

 

class Cat2 extends Animal2
{
//猫自己叫
 public void cry()
 {
  System.out.println("maomaojiao");
 }
 public void eat()
 {
  System.out.println("aichiyu");
 }

}

class Dog2 extends Animal2
{
 //gou自己叫
 public void cry()
 {
  System.out.println("wangwangjiao");
 }
 public void eat()
 {
 
  System.out.println("aichigutou");
 
 }

}

 

第十三讲  抽象类接口 （难点重点）

1.父类方法的不确定性，用抽象类修饰这个方法，abstract。

2.抽象类还是可以一样被继承

3. 当一个类继承的类是抽象的类时候，就要把抽象类中的所有的抽象方法全部方法实现

4.用abstract关键词来修饰的时候，一定是抽象类和抽象方法

5.在使用中不多，公司笔试的时候考很多

6.抽象类不能被实例化，只有被继承以后再去实例化

7.抽象类不一定要包含abstract方法，就算没有abstract方法，也不能实例化它

8.一旦类包含了abstract方法，这个类必须声明为abstract

9.抽象方法不能有主体“{}“

 

 

package com.s1;

 

public class Demo1 {

 

  

    public static void main(String[] args) {

       // TODO Auto-generated method stub

 

    }

 

}

 

abstract class Animal

{

    String name;

    int age;

    abstract public void cry();

  

}

 

//当一个类继承的类是抽象的类时候，就要把抽象类中的所有的抽象方法全部方法实现

class Cat extends Animal

{

    public void cry()

    {

       //do nothing

       System.out.println("喵喵叫");

     

    }

}

 

 

10.接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来，语法：

class 类名 implements 接口

{

         方法；

         变量；

}

 

 

 

package com.s1;

 

public class Demo2 {

    public static void main(String[] args)

    {

       Computer computer=new Computer();

       Camera camera=new Camera();

       Phone phone=new Phone();

       computer.useUsb(camera);

       computer.useUsb(phone);

    }

 

}

 

interface  Usb

{

    //声明了两个方法

    //开始工作

    public void start();

    //停止工作

    public void stop();

  

}

 

//照相机,实现Usb接口

//一个类实现接口就要把所有的类全部实现！

class Camera implements Usb

{

    public void start()

    {

       System.out.println("我是照相机，我开始工作了！");

    }

    public void stop()

    {

       System.out.println("我是照相机，我停止工作了！");

     

    }

     

}

 

//手机类

 

class Phone implements Usb

{

    public void start()

    {

       System.out.println("我是手机，我开始工作了！"); 

    }

    public void stop()

    {

       System.out.println("我是手机，我停止工作了！"); 

     

    }

  

}

 

//计算机

class Computer

{ 

    //开始使用USB接口

    public void useUsb(Usb usb)//体现多态

    {

       usb.start();

       usb.stop();

  

    }

}

11.接口不能被实例化

12.接口中的所有方法都不能有主体

13.抽象类里面是可以有实现了的方法的

14.接口中的所有方法都不能有主体，即都不能被实现

15.接口是更加抽象的抽象类！！！！

16.一个类继承抽象类或是使用接口，那么就要实现所有的抽象方法

17.一个类可以实现多个接口

18.接口中可以有变量（但是不能用private，protected修饰）

19.接口中的变量本质上都是静态的，而且是final，不管你加不加static，所以可以直接使用：接口名.变量名

20.在 java开发中，经常把常用的变量定义在接口中作为全局变量使用

  访问形式：接口名.变量名

21.一个接口不能继承其它的类，但是可以继承别的接口

22.接口体现了程序设计的多态和高内聚低耦合的思想

 

第十四课 final 作业评讲

1.实现接口和继承父类的区别：

2.java是单继承，一个类只允许继承一个父类，这种单继承的机制可以保证类的纯洁性，比C++的多继承机制简洁

3.实现接口可以看做是对单继承的一种补充

4.继承是层次式的，不太灵活，修改某个类就会打破这种继承的平衡，但是接口就不会，因为只针对实现接口的类才起作用

5.用接口体现多态：

6.前期绑定：在程序运行之前就进行绑定，由编译器和连接程序实现，又叫静态绑定，如static方法和final方法，包括private方法，它是隐式fi nal的

7.后期绑定：在运行的时候根据对象的类型进行绑定，由方法调用机制实现，因此又叫动态绑定，或是运行时绑定，除前期绑定外的所有方法都属于后期绑定

8.

//展示接口实现多态的概念

 

package com.s2;

 

//汽车接口

interface Car

{

    String getName();//获得名字

    int getPrice();//获得价格

}

 

//宝马

 class BMW implements Car

 {

     public String getName()

     {

        return "我日，宝马啊";          

     }

     public int getPrice()

     {

        return 800000;

     }

    

 }

 

class QQ implements Car

{

    public String getName()

    {

       return "没意思的，qq";

    }

  

    public int getPrice()

    {

       return 20000;

    }

 

}

 

 

public class CarShop

{

    //售车的收入

    private int money=0;

  

 

    //卖出一部车

    public void sellCar(Car car)

    {

       System.out.println("车型："+car.getName()+"价格是："+car.getPrice());

       money+=car.getPrice();

    }

  

    public int getMoney()

    {

       return money;   

    }

  

    public static void main(String []args)

    {

       CarShop a=new CarShop();

       //卖出宝马

       a.sellCar(new BMW());

       //卖出qq

       a.sellCar(new QQ());

     

       System.out.println("总收入是："+a.getMoney());

     

    }

  

}

9.final概念：final可以修饰变量和方法

当不希望父类的某些方法被子类覆盖的时，可以用final修饰

当不希望类的某个变量的值被修改，可以用final修饰

当不希望类被继承时，可以用final修饰

10.final修饰的变量一般用下划线书写

11.如果一个变量是final的，那么定义时候必须赋初值

12.final修饰的变量又叫常量，一般用XX_XX_XX命名

13.final什么时候用：

  处于安全的考虑，类的某个方法不允许修改

  类不会被其它的类继承

  某些变量值是固定不变的，比如pi