Java第一课

最新推荐文章于 2024-07-19 17:37:28 发布

ShawnAndLove

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量162

点赞数

分类专栏： # Java基础一文章标签： java

本文链接：https://blog.csdn.net/ShawnAndLove/article/details/111578748

版权

Java基础一专栏收录该内容

3 篇文章 1 订阅

订阅专栏

Java基础一

1.面向对象

什么是面向对象

面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。这是百度百科的回答.

如何理解面向对象

个人认为,面向对象是一种编程思想,有人说说"万物皆对象!"

面向对象的几大特征

抽象:抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

封装:封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

代码实现:

   	public class Student {
   		 private int sid;
   		 private String sname;
   		 private int sage;
   }

说明: 将sid,sname,sage这三个属性设置成私有的,只有在本类中才能调用,如此就将数据进行了隐藏,从而实现了封装

封装之后也可以提供存值取值的方法:

public int getSid() {
    return sid;
}

public void setSid(int sid) {
    this.sid = sid;
}

public String getSname() {
    return sname;
}

public void setSname(String sname) {
    this.sname = sname;
}

public int getSage() {
    return sage;
}

public void setSage(int sage) {
    this.sage = sage;
}

这里就看到了一个新的名词 this,可以联想到super

this:

当类中非静态方法的参数名与类的某个成员变量名相同时，为了避免参数作用范围覆盖了成员变量的作用范围，必须明确使用this关键字来指定
如果某个构造方法的第一条语句具有形式this(…)，那么这个构造方法将调用本类中的其他构造方法
如果某个方法需要传入当前对象，则可以将当前的对象作为参数传递给它

    	public class Student {
      		 private int sid;
     		 private String sname;
      		 private int sage;

   			 public Student(int id,String name,int age){
  				super();
  				this.sname = sname;
   				this.sage = sage;
   				this.sid = sid;
   		    }
 			 public Student(){
 				 this(1,"天才",20);
 		  	}
   	}

super:

super可以用来引用直接父类的实例变量。
super可以用来调用直接父类方法。
super()可以用于调用直接父类构造函数

        class C {
           String name = "A";
           public void work() {
               System.out.println("A工作!");
           }
       }

       class B extends C {
           String name = "B";
           public B() {
               super(); // 调用父类构造方法
           }
           public void work() {
               System.out.println("B工作！");
           }

           public void pint() {
               System.out.println(name);
               System.out.println(super.name); // 调用父类的实例变量
               super.work(); // 调用父类的方法
           }
       }
       public  class A {
           public  static void main(String[] args) {
               B b =  new B();
               b.pint();
           }
   }

再说一说this与super的区别:

	this	super
含义	是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。	super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。
使用条件不同	没有继承关系也可以使用	必须存在继承关系才可以使用
调用的函数不同	调用的是当前类中的构造函数	调用的是父类中的构造函数

继承:继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类《子类)，而原始类称为新类的基类《父类)。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
- 继承的格式: class 子类 extends 父类 {}
- 继承的优点:
  (1) 提高类代码的复用性
  (2) 提高了代码的维护性
  (3) 使得类和类产生了关系，是多态的前提(它也是继承的一个弊端，类的耦合性提高了)
- 继承的特性:
  - 子类拥有父类非 private 的属性、方法。
  - 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
  - 子类可以重写父类的方法
  - Java只支持单继承,但是可以多重继承.举个栗子,有A,B,C三个类,Java就是不支持A继承B再继承C,但是可以A继承B,让B去继承C,这样在A类中就可以使用C中的方法了!!
  - 提高了类之间的耦合性(这也是继承的缺点,类之间的联系越紧密,耦合度就越高,独立性就越差)

多态:多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性,简而言之:多态是同一个行为具有多个不同表现形式或形态的能力。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题
- 多态是面向对象的最后一个主要特征，它本身主要分为两个方面：
  - 方法的多态性:重载与覆写
    - 重载:同一个方法，根据不同的参数类型及个数可以完成不同的功能。
    - 覆写:同一个方法，根据操作的子类不同，所完成的功能也不同。
  - 对象的多态:父子类对象的转换。
    - 向上转型:子类对象变为父类对象，格式：父类父类对象 = 子类实例，自动；
    - 向下转型:父类对象变为子类对象，格式：子类子类对象 = (子类)父类实例，强制。
- 多态的优点:
  - 消除类型之间的耦合关系
  - 可替换性
  - 可扩充性
  - 接口性
  - 灵活性
  - 简化性
- 多态存在的三个必要条件
  - 继承
  - 重写
  - 父类引用指向子类对象

面向对象的五大原则

单一职责原则(SRP):类的功能要单一，不能包罗万象，跟杂货铺似的。
开放封闭原则(OCP):一个模块对于拓展是开放的，对于修改是封闭的，想要增加功能热烈欢迎，想要修改，哼，一万个不乐意。
里氏替换原则(LSP):子类可以替换父类出现在父类能够出现的任何地方。比如你能代表你爸去你姥姥家干活。哈哈
依赖倒置原则(DIP):高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。就是你出国要说你是中国人，而不能说你是哪个村子的。比如说中国人是抽象的，下面有具体的xx省，xx市，xx县。你要依赖的是抽象的中国人，而不是你是xx村的。
接口分离原则(ISP):设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。就比如一个手机拥有打电话，看视频，玩游戏等功能，把这几个功能拆分成不同的接口，比在一个接口里要好的多.

基本数据类型

Java 的两大数据类型:

内置数据类型
数据类型默认值
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
char ‘u0000’
boolean false
引用数据类型
- 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
- 对象、数组都是引用数据类型。
- 所有引用类型的默认值都是null。
- 一个引用变量可以用来引用任何与之兼容的类型。
- 例子：Site site = new Site(“Runoob”)。
数据类型转换:整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级。
- 数据类型转换必须满足如下规则：
- 不能对boolean类型进行类型转换。
- 不能把对象类型转换成不相关类的对象。
- 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
- 转换过程中可能导致溢出或损失精度
- 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入
数据类型强制转换
- 条件是转换的数据类型必须是兼容的。
- 格式：(type)value type是要强制类型转换后的数据类型

数据类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	‘u0000’
boolean	false

String

String类型常用的方法:

length():获取字符串的长度，其实也就是字符个数

  	 String str = "我叫小明今年十八想要女朋友";
       System.out.println(str.length());

输出: 13

charAt(int index):获取指定索引处的字符

String str = "我叫小明今年十八想要女朋友";
System.out.println(str.charAt(6));

输出: 十

indexOf(String str):获取str在字符串对象中第一次出现的索引

      String str = "我叫小明今年十八想要女朋友";
      System.out.println(str.indexOf('女'));

输出: 10

substring(int start):从start开始截取字符串

String str = "我叫小明今年十八想要女朋友";
System.out.println(str.substring(1));

输出: 叫小明今年十八想要女朋友

String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
```
String str = "我叫小明今年十八想要女朋友";
     System.out.println(str.substring(1, 12));
```
输出: 叫小明今年十八想要女朋

equals(Object obj):比较字符串的内容是否相同

	 String str = "我叫小明今年十八想要女朋友";
     System.out.println(str.equals("我叫小明今年十八想要女朋友"));
     System.out.println(str.equals("adsfaxsdfas"));

输出: true false

equalsIgnoreCase(String anotherString):比较字符串的内容是否相同,忽略大小写

String str = "abcdABCD我叫小明今年十八想要女朋友";
     System.out.println(str.equalsIgnoreCase("abcdABCD我叫小明今年十八想要女朋友"));

输出: true

startsWith(String prefix):判断字符串对象是否以指定的字符开头（区分大小写）

   String str = "abcdABCD我叫小明今年十八想要女朋友";
     System.out.println(str.startsWith("a"));
     System.out.println(str.startsWith("A"));

输出: true false

startsWith(String prefix,int toffset)：判断字符串对象是否以指定的字符开头，参数toffset为指定从哪个下标开始

    String str = "abcdABCD我叫小明今年十八想要女朋友";
     System.out.println(str.startsWith("c", 2));
     System.out.println(str.startsWith("c", 3));

输出:true false

endsWith(String str):判断字符串对象是否以指定的字符结尾

String str = "abcdABCD我叫小明今年十八想要女朋友";
     System.out.println(str.endsWith("友"));
     System.out.println(str.endsWith("有"));

true false

isEmpty()：判断指定字符串是否为空

String str = "abcdABCD我叫小明今年十八想要女朋友";
     System.out.println(str.isEmpty());

输出: false

toCharArray():把字符串转换为字符数组
toLowerCase():把字符串转换为小写字符串
toUpperCase():把字符串转换为大写字符串

trim()：去除字符串两端空格
split():去除字符串中指定的的字符，然后返回一个新的字符串
subSequence(int beginIndex,int endIndex )：截取字符串中指定位置的字符组成一个新的字符串
replace(char oldChar, char newChar)：将指定字符替换成另一个指定的字符
replaceAll(String regex,String replasement)：用新的内容替换全部旧内容
replaceFirst(String regex,String replacement)：替换首个满足条件的内容
lastIndexOf(String str)：返回指定字符出现的最后一次的下标
contains(CharSequence s)：查看字符串中是都含有指定字符
concat(String str)：在原有的字符串的基础上加上指定字符串

判断循环条件分支

判断

if…else:

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。

语法:

    if(布尔表达式){
    //如果布尔表达式的值为true
 	}else{
    //如果布尔表达式的值为false
 	}

实例:

public class Test {
public static void main(String args[]){
   int x = 30;
   if( x < 20 ){
      System.out.print("这是 if 语句");
   }else{
      System.out.print("这是 else 语句");
   }
}
}

运行结果: 这是 else 语句

if…else if…else 语句:

if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。

使用 if，else if，else 语句的时候，需要注意下面几点：
- if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
- if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
- 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

语法:

    if(布尔表达式 1){
	   //如果布尔表达式 1的值为true执行代码
	}else if(布尔表达式 2){
	   //如果布尔表达式 2的值为true执行代码
	}else if(布尔表达式 3){
	   //如果布尔表达式 3的值为true执行代码
	}else {
	   //如果以上布尔表达式都不为true执行代码
	}

实例:

   public class Test {
   public static void main(String args[]){
      int x = 30;
      if( x == 10 ){
         System.out.print("Value of X is 10");
      }else if( x == 20 ){
         System.out.print("Value of X is 20");
      }else if( x == 30 ){
         System.out.print("Value of X is 30");
      }else{
         System.out.print("这是 else 语句");
      }
   }
}

运行结果: Value of X is 30

嵌套的 if…else 语句:

使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。

语法:

if(布尔表达式 1){
   如果布尔表达式 1的值为true执行代码
   if(布尔表达式 2){
      如果布尔表达式 2的值为true执行代码
   }
}

实例:

public class Test {
   public static void main(String args[]){
      int x = 30;
      int y = 10;
      if( x == 30 ){
         if( y == 10 ){
             System.out.print("X = 30 and Y = 10");
          }
       }
    }
}

运行结果: X = 30 and Y = 10

循环

Java中有三种主要的循环结构：

while循环
do…while 循环
for循环

while 循环:

while是最基本的循环

结构

    while( 布尔表达式 ) {
	  //循环内容
	}

实例

   public class Test {
   public static void main(String args[]) {
      int x = 10;
      while( x < 20 ) {
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }
   }
}

运行结果:
value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

do…while 循环 :

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

语法:

    do {
       //代码语句
	}while(布尔表达式);

实例:

public class Test {
   public static void main(String args[]){
      int x = 10; 
      do{
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }while( x < 20 );
   }
}

运行结果: value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

for循环:

虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单

语法:

for(初始化; 布尔表达式; 更新) {
//代码语句
}

说明:
- 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
- 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
- 执行一次循环后，更新循环控制变量。
- 再次检测布尔表达式。循环执行上面的过程。

实例:

    public class Test {
   public static void main(String args[]) { 
      for(int x = 10; x < 20; x = x+1) {
         System.out.print("value of x : " + x );
         System.out.print("\n");
      }
   }
}

运行结果:
value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

Java 增强 for 循环:

Java5 引入了一种主要用于数组的增强型 for 循环.

语法:

    for(声明语句 : 表达式)
	{
	   //代码句子
	}

实例:

public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50}; 
      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

运行结果:
10,20,30,40,50,
James,Larry,Tom,Lacy

break 关键字:

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。 break 跳出最里层的循环，并且继续执行该循环下面的语句。

语法:
```
break;
```

实例:

public class Test {
   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ) {
         // x 等于 30 时跳出循环
         if( x == 30 ) {
            break;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

运行结果:
10
20

continue 关键字:

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

语法:
```
continue;
```

实例:

    public class Test {
   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50}; 
      for(int x : numbers ) {
         if( x == 30 ) {
        continue;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

运行结果:
10
20
40
50

条件分支

条件分支语句

说明:

条件分支语句:可以利用一些结构打断程序，或者挑选分支执行，或者循环执行某一段语句
包含：条件分支语句、循环语句
条件分支语句：if语句、switch语句、三元运算符

if语句

语法

 if(条件表达式){
  条件表达式成立执行
  }
   if(条件表达式){
  　　　条件表达式成立执行
  　　}else{
  　　　条件表示不成立执行
  }

实例

   if(num>=60){
      alert('及格');
   }else{
      alert('不及格');
   }

if多分支条件语句

语法

    if(条件1){
  　　　如果条件1为真，执行的结构体1
  　　  }else if(条件2){
  　	　条件1为假，条件2为真时，执行的结构体2
  　　 }else if(条件3){
  　	　  条件1/2都为假，条件3为真时，执行的结构体3
  　　  }else{
  　　	　 前面条件都为假，执行的结构体
  	}

实例

   var num=parseInt(prompt('请输入你的分数'));
   if(num >= 90){
     alert('优秀');
   }else if(num >= 80){ //如果走到这一步，隐含了a<90
     alert('良好');   //执行完之后，直接跳楼，不会执行后面的条件分之
   }else if(num >= 70){
     alert('中等');
   }else if(num >= 60){ //如果走到这一步，隐含了a<70
     alert('及格');
   }else{
     alert('不及格');
   }

if嵌套

  var sex=prompt('请输入你的性别','男');
  var age=parseInt(prompt('请输入你的年纪'));
  if(sex == '男'){
         //只要进来执行，性别肯定是男
  //判断年龄确定是否大于等于22
      if(age >= 22){
      alert('恭喜你！小鲜肉可以结婚了');
      }else{
      alert('小鲜肉，再坚持一会！');
       }
   else if(sex == '女'){
       if(age >= 20){
        alert('小萝莉，恭喜你！可以结婚了');
       }else{
        alert('小萝莉，再坚持一会！');
      }
  }else{
    //进入这个条件分支语句，说明不是男也不是女，是人妖
    alert('人妖，走开！');
  }

switch case语句

switch：关键字

case：匹配案例

break：打断代码，跳出整个switch语句

default：相当于if语句中的else，否则的情况

语法

	switch(待检测的值){
	case 值1:
	值1与待检测的值匹配时执行
	break;
	case 值2:
	值2与待检测的值匹配时执行
	break;
	case 值3:
	值3与待检测的值匹配时执行
	break;
	default:
	待检测的值 与 case 1 和 case 2、case 3 不同时执行的代码
	}

结构

   var xingzuo=prompt('请输入你的星座' ,'金牛座');
    switch(xingzuo){
    case "白羊座":
        alert('今日的精神状态较好，一些重要的、消耗脑力的事情');
        break;
    case "金牛座":
        alert('职场上的责任心不强，偶尔推卸责任，很难得到同事');
        break;
    case "巨蟹座":
        alert('今天要是工作量太多太重的话，可以请同事帮忙一下');
         break;
     case "狮子座":
         alert('对新鲜事物有很强的求知欲，这样的心态对事业好');
         break;
     case "天秤座":
         alert('整个人精神爽利，桃花滚滚来，单身者有福咯!');
         break;
     case "水瓶座":
         alert('今日职场上运气好，时刻都受到大家的照顾，即使有!');
         break;
     default:
         alert('对不起，我们没有收录你的星座运势');
    }

三元运算符

是什么?:
是一组运算符，这是JS唯一一个需要三个元素参与的运算符。
语法
条件 ? val1 : val2
表达式的值，要看条件是true还是false。
如果条件是true，那么表达式的值就是val1。
如果条件是false，那么表达式的值就是val2。

结构

     <script type="text/javascript">
       console.log(true ? 3:8);  //3
       console.log(false ? 3:8); //8
      </script>

2.面向对象与面向过程的通俗理解

看看俺说的对吗

3.java集合体系(大部分内容来自菜鸟教程)

管它学会学不会,看了总比不看强

部分内容借鉴自以下博文:

https://blog.csdn.net/sugar_no1/article/details/86366714

https://blog.csdn.net/mm_3_by/article/details/82194369

ShawnAndLove

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java第一课

Java基础一1.面向对象什么是面向对象:如何理解面向对象面向对象的特征基本数据类型String判断循环条件分支2.java集合体系。3.jvm结构，GC机制,GC算法（GC调优)Java基础一1.面向对象什么是面向对象:面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。这是百度百科的回答.如何理解面向对象个人认为,面向对象是一种编程思想,行话说"万物皆对象!"面向对象的特征.
复制链接

扫一扫